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 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/animation/animation-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/window.h>
 439 #include <dali/public-api/adaptor-framework/style-change.h>
 440 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 441 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 442 #include <dali/devel-api/adaptor-framework/window-devel.h>
 443
 444 #include <dali/devel-api/images/nine-patch-image.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 454 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 458 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 459 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 460 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 461
 462 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 463 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 464 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 465
 466 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 470
 471 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 472
 473 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 474
 475
 476 // add here SWIG version check
 477
 478 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 479 // disable Swig-dependent warnings
 480
 481 // 'identifier1' has C-linkage specified,
 482 // but returns UDT 'identifier2' which is incompatible with C
 483 #pragma warning(disable: 4190)
 484
 485 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 486 #pragma warning(disable: 4800)
 487
 488 // debug info too long etc etc
 489 #pragma warning(disable: 4786)
 490 #endif
 491
 492
 493 #include <stdexcept>
 494
 495
 496 #include <string>
 497
 498
 499 #include <vector>
 500 #include <algorithm>
 501 #include <stdexcept>
 502
 503
 504 #include <map>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <utility>
 510
 511
 512 typedef float floatp;
 513
 514 SWIGINTERN floatp *new_floatp(){
 515   return new float();
 516 }
 517 SWIGINTERN void delete_floatp(floatp *self){
 518   if (self) delete self;
 519 }
 520 SWIGINTERN void floatp_assign(floatp *self,float value){
 521   *self = value;
 522 }
 523 SWIGINTERN float floatp_value(floatp *self){
 524   return *self;
 525 }
 526 SWIGINTERN float *floatp_cast(floatp *self){
 527   return self;
 528 }
 529 SWIGINTERN floatp *floatp_frompointer(float *t){
 530   return (floatp *) t;
 531 }
 532
 533 typedef int intp;
 534
 535 SWIGINTERN intp *new_intp(){
 536   return new int();
 537 }
 538 SWIGINTERN void delete_intp(intp *self){
 539   if (self) delete self;
 540 }
 541 SWIGINTERN void intp_assign(intp *self,int value){
 542   *self = value;
 543 }
 544 SWIGINTERN int intp_value(intp *self){
 545   return *self;
 546 }
 547 SWIGINTERN int *intp_cast(intp *self){
 548   return self;
 549 }
 550 SWIGINTERN intp *intp_frompointer(int *t){
 551   return (intp *) t;
 552 }
 553
 554 typedef double doublep;
 555
 556 SWIGINTERN doublep *new_doublep(){
 557   return new double();
 558 }
 559 SWIGINTERN void delete_doublep(doublep *self){
 560   if (self) delete self;
 561 }
 562 SWIGINTERN void doublep_assign(doublep *self,double value){
 563   *self = value;
 564 }
 565 SWIGINTERN double doublep_value(doublep *self){
 566   return *self;
 567 }
 568 SWIGINTERN double *doublep_cast(doublep *self){
 569   return self;
 570 }
 571 SWIGINTERN doublep *doublep_frompointer(double *t){
 572   return (doublep *) t;
 573 }
 574
 575 typedef unsigned int uintp;
 576
 577 SWIGINTERN uintp *new_uintp(){
 578   return new unsigned int();
 579 }
 580 SWIGINTERN void delete_uintp(uintp *self){
 581   if (self) delete self;
 582 }
 583 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 584   *self = value;
 585 }
 586 SWIGINTERN unsigned int uintp_value(uintp *self){
 587   return *self;
 588 }
 589 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 590   return self;
 591 }
 592 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 593   return (uintp *) t;
 594 }
 595
 596 typedef unsigned short ushortp;
 597
 598 SWIGINTERN ushortp *new_ushortp(){
 599   return new unsigned short();
 600 }
 601 SWIGINTERN void delete_ushortp(ushortp *self){
 602   if (self) delete self;
 603 }
 604 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 605   *self = value;
 606 }
 607 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 608   return *self;
 609 }
 610 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 611   return self;
 612 }
 613 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 614   return (ushortp *) t;
 615 }
 616
 617 unsigned int int_to_uint(int x) {
 618    return (unsigned int) x;
 619 }
 620
 621
 622 using namespace Dali;
 623 using namespace Dali::Toolkit;
 624
 625 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 626
 627      // C++ code. DALi uses Handle <-> Body design pattern.
 628      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 629      // Handles in DALi can be converted into a boolean type
 630      // to check if the handle has a valid body attached to it.
 631      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 632      if( *self )
 633      {
 634        return true;
 635      }
 636      else
 637      {
 638        return false;
 639      }
 640     }
 641 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 642
 643      // C++ code. Check if two handles reference the same implemtion
 644      if( *self == rhs)
 645      {
 646        return true;
 647      }
 648      else
 649      {
 650        return false;
 651      }
 652     }
 653 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 654      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 655    }
 656 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){
 657      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 658    }
 659 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 660         std::vector< Dali::TouchPoint >* pv = 0;
 661         if (capacity >= 0) {
 662           pv = new std::vector< Dali::TouchPoint >();
 663           pv->reserve(capacity);
 664        } else {
 665           throw std::out_of_range("capacity");
 666        }
 667        return pv;
 668       }
 669 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 670         if (index>=0 && index<(int)self->size())
 671           return (*self)[index];
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 676         if (index>=0 && index<(int)self->size())
 677           return (*self)[index];
 678         else
 679           throw std::out_of_range("index");
 680       }
 681 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 682         if (index>=0 && index<(int)self->size())
 683           (*self)[index] = val;
 684         else
 685           throw std::out_of_range("index");
 686       }
 687 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 688         self->insert(self->end(), values.begin(), values.end());
 689       }
 690 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 691         if (index < 0)
 692           throw std::out_of_range("index");
 693         if (count < 0)
 694           throw std::out_of_range("count");
 695         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 696           throw std::invalid_argument("invalid range");
 697         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 700         if (index>=0 && index<(int)self->size()+1)
 701           self->insert(self->begin()+index, x);
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 706         if (index>=0 && index<(int)self->size()+1)
 707           self->insert(self->begin()+index, values.begin(), values.end());
 708         else
 709           throw std::out_of_range("index");
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 712         if (index>=0 && index<(int)self->size())
 713           self->erase(self->begin() + index);
 714         else
 715           throw std::out_of_range("index");
 716       }
 717 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 718         if (index < 0)
 719           throw std::out_of_range("index");
 720         if (count < 0)
 721           throw std::out_of_range("count");
 722         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 723           throw std::invalid_argument("invalid range");
 724         self->erase(self->begin()+index, self->begin()+index+count);
 725       }
 726 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 727         if (count < 0)
 728           throw std::out_of_range("count");
 729         return new std::vector< Dali::TouchPoint >(count, value);
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 732         std::reverse(self->begin(), self->end());
 733       }
 734 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 735         if (index < 0)
 736           throw std::out_of_range("index");
 737         if (count < 0)
 738           throw std::out_of_range("count");
 739         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 740           throw std::invalid_argument("invalid range");
 741         std::reverse(self->begin()+index, self->begin()+index+count);
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 744         if (index < 0)
 745           throw std::out_of_range("index");
 746         if (index+values.size() > self->size())
 747           throw std::out_of_range("index");
 748         std::copy(values.begin(), values.end(), self->begin()+index);
 749       }
 750 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 751          return self->Empty();
 752       }
 753 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 754         return self->GetConnectionCount();
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 757           self->Connect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 760           self->Disconnect( func );
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 763           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 764 /*@SWIG@*/ self->Emit( arg );
 765       }
 766 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 767          return self->Empty();
 768       }
 769 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 770         return self->GetConnectionCount();
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 773           self->Connect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 776           self->Disconnect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 779           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 780 /*@SWIG@*/ self->Emit( arg );
 781       }
 782 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 783          return self->Empty();
 784       }
 785 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){
 786         return self->GetConnectionCount();
 787       }
 788 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 *)){
 789           self->Connect( func );
 790       }
 791 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 *)){
 792           self->Disconnect( func );
 793       }
 794 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){
 795           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 796 /*@SWIG@*/ self->Emit( arg );
 797       }
 798 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 799          return self->Empty();
 800       }
 801 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 802         return self->GetConnectionCount();
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 805           self->Connect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 808           self->Disconnect( func );
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 811           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 812 /*@SWIG@*/ self->Emit( arg );
 813       }
 814 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 815          return self->Empty();
 816       }
 817 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 818         return self->GetConnectionCount();
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 821           self->Connect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 824           self->Disconnect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 827           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 828 /*@SWIG@*/ self->Emit( arg );
 829       }
 830 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){
 831          return self->Empty();
 832       }
 833 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){
 834         return self->GetConnectionCount();
 835       }
 836 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 &)){
 837         self->Connect( func );
 838       }
 839 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 &)){
 840         self->Disconnect( func );
 841       }
 842 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){
 843         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 844 /*@SWIG@*/ self->Emit( arg1, arg2 );
 845       }
 846 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){
 847          return self->Empty();
 848       }
 849 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){
 850         return self->GetConnectionCount();
 851       }
 852 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 &)){
 853         self->Connect( func );
 854       }
 855 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 &)){
 856         self->Disconnect( func );
 857       }
 858 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){
 859         return self->Emit( arg1, arg2 );
 860       }
 861 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){
 862          return self->Empty();
 863       }
 864 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){
 865         return self->GetConnectionCount();
 866       }
 867 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 &)){
 868         self->Connect( func );
 869       }
 870 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 &)){
 871         self->Disconnect( func );
 872       }
 873 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){
 874         return self->Emit( arg1, arg2 );
 875       }
 876 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){
 877          return self->Empty();
 878       }
 879 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){
 880         return self->GetConnectionCount();
 881       }
 882 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 &)){
 883         self->Connect( func );
 884       }
 885 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 &)){
 886         self->Disconnect( func );
 887       }
 888 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){
 889         return self->Emit( arg1, arg2 );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 892          return self->Empty();
 893       }
 894 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 895         return self->GetConnectionCount();
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 898           self->Connect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 901           self->Disconnect( func );
 902       }
 903 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 904           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg );
 906       }
 907 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 908          return self->Empty();
 909       }
 910 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){
 911         return self->GetConnectionCount();
 912       }
 913 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 &)){
 914           self->Connect( func );
 915       }
 916 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 &)){
 917           self->Disconnect( func );
 918       }
 919 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){
 920           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 921 /*@SWIG@*/ self->Emit( arg );
 922       }
 923 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 924          return self->Empty();
 925       }
 926 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){
 927         return self->GetConnectionCount();
 928       }
 929 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 &)){
 930           self->Connect( func );
 931       }
 932 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 &)){
 933           self->Disconnect( func );
 934       }
 935 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){
 936           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 937 /*@SWIG@*/ self->Emit( arg );
 938       }
 939 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 940          return self->Empty();
 941       }
 942 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){
 943         return self->GetConnectionCount();
 944       }
 945 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 &)){
 946           self->Connect( func );
 947       }
 948 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 &)){
 949           self->Disconnect( func );
 950       }
 951 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){
 952           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg );
 954       }
 955 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){
 956          return self->Empty();
 957       }
 958 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){
 959         return self->GetConnectionCount();
 960       }
 961 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 &)){
 962         self->Connect( func );
 963       }
 964 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 &)){
 965         self->Disconnect( func );
 966       }
 967 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){
 968         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg1, arg2 );
 970       }
 971 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){
 972          return self->Empty();
 973       }
 974 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){
 975         return self->GetConnectionCount();
 976       }
 977 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 &)){
 978         self->Connect( func );
 979       }
 980 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 &)){
 981         self->Disconnect( func );
 982       }
 983 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){
 984         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg1, arg2 );
 986       }
 987 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){
 988          return self->Empty();
 989       }
 990 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){
 991         return self->GetConnectionCount();
 992       }
 993 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 &)){
 994         self->Connect( func );
 995       }
 996 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 &)){
 997         self->Disconnect( func );
 998       }
 999 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){
1000         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1001 /*@SWIG@*/ self->Emit( arg1, arg2 );
1002       }
1003 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1004          return self->Empty();
1005       }
1006 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1007         return self->GetConnectionCount();
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1010           self->Connect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1013           self->Disconnect( func );
1014       }
1015 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1016           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1017 /*@SWIG@*/ self->Emit( arg );
1018       }
1019 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1020          return self->Empty();
1021       }
1022 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1023         return self->GetConnectionCount();
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1026           self->Connect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1029           self->Disconnect( func );
1030       }
1031 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1032           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1033 /*@SWIG@*/ self->Emit( arg );
1034       }
1035 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){
1036          return self->Empty();
1037       }
1038 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){
1039         return self->GetConnectionCount();
1040       }
1041 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)){
1042           return self->Connect( func );
1043       }
1044 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)){
1045           self->Disconnect( func );
1046       }
1047 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){
1048           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1049 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1050       }
1051
1052   // keep argcs and argv so they're always available to DALi
1053   int argC = 1;
1054   char **argV = NULL;
1055
1056 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1057          return self->Empty();
1058       }
1059 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1060         return self->GetConnectionCount();
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1063           self->Connect( func );
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1066           self->Disconnect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1069           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1070 /*@SWIG@*/ self->Emit( arg );
1071       }
1072 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1073          return self->Empty();
1074       }
1075 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1076         return self->GetConnectionCount();
1077       }
1078 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1079         self->Connect( func );
1080       }
1081 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1082         self->Disconnect( func );
1083       }
1084 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1085         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1086 /*@SWIG@*/ self->Emit( arg1, arg2 );
1087       }
1088 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1089          return self->Empty();
1090       }
1091 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1092         return self->GetConnectionCount();
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1095           self->Connect( func );
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Disconnect( func );
1099       }
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1101           return self->Emit();
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1104          return self->Empty();
1105       }
1106 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1107         return self->GetConnectionCount();
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1110           self->Connect( func );
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1113           self->Disconnect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1116           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1117 /*@SWIG@*/ self->Emit( arg );
1118       }
1119 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1120         std::vector< unsigned int >* pv = 0;
1121         if (capacity >= 0) {
1122           pv = new std::vector< unsigned int >();
1123           pv->reserve(capacity);
1124        } else {
1125           throw std::out_of_range("capacity");
1126        }
1127        return pv;
1128       }
1129 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           return (*self)[index];
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1142         if (index>=0 && index<(int)self->size())
1143           (*self)[index] = val;
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1148         self->insert(self->end(), values.begin(), values.end());
1149       }
1150 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (count < 0)
1154           throw std::out_of_range("count");
1155         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1156           throw std::invalid_argument("invalid range");
1157         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1160         if (index>=0 && index<(int)self->size()+1)
1161           self->insert(self->begin()+index, x);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, values.begin(), values.end());
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1172         if (index>=0 && index<(int)self->size())
1173           self->erase(self->begin() + index);
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         self->erase(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1187         if (count < 0)
1188           throw std::out_of_range("count");
1189         return new std::vector< unsigned int >(count, value);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1192         std::reverse(self->begin(), self->end());
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         std::reverse(self->begin()+index, self->begin()+index+count);
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (index+values.size() > self->size())
1207           throw std::out_of_range("index");
1208         std::copy(values.begin(), values.end(), self->begin()+index);
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1211         return std::find(self->begin(), self->end(), value) != self->end();
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1216         if (it != self->end())
1217           index = (int)(it - self->begin());
1218         return index;
1219       }
1220 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1221         int index = -1;
1222         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1223         if (rit != self->rend())
1224           index = (int)(self->rend() - 1 - rit);
1225         return index;
1226       }
1227 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1228         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1229         if (it != self->end()) {
1230           self->erase(it);
1231           return true;
1232         }
1233         return false;
1234       }
1235 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){
1236         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1237         if (capacity >= 0) {
1238           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1239           pv->reserve(capacity);
1240        } else {
1241           throw std::out_of_range("capacity");
1242        }
1243        return pv;
1244       }
1245 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){
1246         if (index>=0 && index<(int)self->size())
1247           return (*self)[index];
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size())
1259           (*self)[index] = val;
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         self->insert(self->end(), values.begin(), values.end());
1265       }
1266 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){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (count < 0)
1270           throw std::out_of_range("count");
1271         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1272           throw std::invalid_argument("invalid range");
1273         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1274       }
1275 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){
1276         if (index>=0 && index<(int)self->size()+1)
1277           self->insert(self->begin()+index, x);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 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){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, values.begin(), values.end());
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 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){
1288         if (index>=0 && index<(int)self->size())
1289           self->erase(self->begin() + index);
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 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){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         self->erase(self->begin()+index, self->begin()+index+count);
1301       }
1302 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){
1303         if (count < 0)
1304           throw std::out_of_range("count");
1305         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1306       }
1307 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){
1308         std::reverse(self->begin(), self->end());
1309       }
1310 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){
1311         if (index < 0)
1312           throw std::out_of_range("index");
1313         if (count < 0)
1314           throw std::out_of_range("count");
1315         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1316           throw std::invalid_argument("invalid range");
1317         std::reverse(self->begin()+index, self->begin()+index+count);
1318       }
1319 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){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (index+values.size() > self->size())
1323           throw std::out_of_range("index");
1324         std::copy(values.begin(), values.end(), self->begin()+index);
1325       }
1326 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1327         std::vector< Dali::Actor >* pv = 0;
1328         if (capacity >= 0) {
1329           pv = new std::vector< Dali::Actor >();
1330           pv->reserve(capacity);
1331        } else {
1332           throw std::out_of_range("capacity");
1333        }
1334        return pv;
1335       }
1336 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           return (*self)[index];
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1349         if (index>=0 && index<(int)self->size())
1350           (*self)[index] = val;
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1355         self->insert(self->end(), values.begin(), values.end());
1356       }
1357 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (count < 0)
1361           throw std::out_of_range("count");
1362         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1363           throw std::invalid_argument("invalid range");
1364         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1367         if (index>=0 && index<(int)self->size()+1)
1368           self->insert(self->begin()+index, x);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, values.begin(), values.end());
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1379         if (index>=0 && index<(int)self->size())
1380           self->erase(self->begin() + index);
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         self->erase(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1394         if (count < 0)
1395           throw std::out_of_range("count");
1396         return new std::vector< Dali::Actor >(count, value);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1399         std::reverse(self->begin(), self->end());
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1402         if (index < 0)
1403           throw std::out_of_range("index");
1404         if (count < 0)
1405           throw std::out_of_range("count");
1406         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1407           throw std::invalid_argument("invalid range");
1408         std::reverse(self->begin()+index, self->begin()+index+count);
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (index+values.size() > self->size())
1414           throw std::out_of_range("index");
1415         std::copy(values.begin(), values.end(), self->begin()+index);
1416       }
1417 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418          return self->Empty();
1419       }
1420 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421         return self->GetConnectionCount();
1422       }
1423 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 &)){
1424           self->Connect( func );
1425       }
1426 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 &)){
1427           self->Disconnect( func );
1428       }
1429 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){
1430           return self->Emit( arg );
1431       }
1432 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){
1433          return self->Empty();
1434       }
1435 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){
1436         return self->GetConnectionCount();
1437       }
1438 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)){
1439         self->Connect( func );
1440       }
1441 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)){
1442         self->Disconnect( func );
1443       }
1444 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){
1445         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1446 /*@SWIG@*/ self->Emit( arg1, arg2 );
1447       }
1448 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1449          return self->Empty();
1450       }
1451 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){
1452         return self->GetConnectionCount();
1453       }
1454 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)){
1455         self->Connect( func );
1456       }
1457 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)){
1458         self->Disconnect( func );
1459       }
1460 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){
1461         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1462 /*@SWIG@*/ self->Emit( arg1, arg2 );
1463       }
1464 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465          return self->Empty();
1466       }
1467 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468         return self->GetConnectionCount();
1469       }
1470 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)){
1471         self->Connect( func );
1472       }
1473 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)){
1474         self->Disconnect( func );
1475       }
1476 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){
1477         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1478 /*@SWIG@*/ self->Emit( arg1, arg2 );
1479       }
1480 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){
1481          return self->Empty();
1482       }
1483 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){
1484         return self->GetConnectionCount();
1485       }
1486 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)){
1487         self->Connect( func );
1488       }
1489 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)){
1490         self->Disconnect( func );
1491       }
1492 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){
1493         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1494 /*@SWIG@*/ self->Emit( arg1, arg2 );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497          return self->Empty();
1498       }
1499 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500         return self->GetConnectionCount();
1501       }
1502 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)){
1503           self->Connect( func );
1504       }
1505 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)){
1506           self->Disconnect( func );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1509           return self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 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)){
1518           self->Connect( func );
1519       }
1520 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)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 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){
1528          return self->Empty();
1529       }
1530 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){
1531         return self->GetConnectionCount();
1532       }
1533 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)){
1534           return self->Connect( func );
1535       }
1536 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)){
1537           self->Disconnect( func );
1538       }
1539 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){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 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)){
1550           self->Connect( func );
1551       }
1552 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)){
1553           self->Disconnect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1556           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1557 /*@SWIG@*/ self->Emit( arg );
1558       }
1559 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){
1560          return self->Empty();
1561       }
1562 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){
1563         return self->GetConnectionCount();
1564       }
1565 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)){
1566           return self->Connect( func );
1567       }
1568 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)){
1569           self->Disconnect( func );
1570       }
1571 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){
1572           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1573 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1574       }
1575 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){
1576          return self->Empty();
1577       }
1578 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){
1579         return self->GetConnectionCount();
1580       }
1581 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 &)){
1582           self->Connect( func );
1583       }
1584 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 &)){
1585           self->Disconnect( func );
1586       }
1587 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){
1588           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1589 /*@SWIG@*/ self->Emit( arg );
1590       }
1591 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1592          return self->Empty();
1593       }
1594 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){
1595         return self->GetConnectionCount();
1596       }
1597 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 &)){
1598           self->Connect( func );
1599       }
1600 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 &)){
1601           self->Disconnect( func );
1602       }
1603 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){
1604           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1605 /*@SWIG@*/ self->Emit( arg );
1606       }
1607 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1608          return self->Empty();
1609       }
1610 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1611         return self->GetConnectionCount();
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1614           self->Connect( func );
1615       }
1616 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1617           self->Disconnect( func );
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1620           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1621 /*@SWIG@*/ self->Emit( arg );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1630           self->Connect( func );
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1633           self->Disconnect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 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){
1640          return self->Empty();
1641       }
1642 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){
1643         return self->GetConnectionCount();
1644       }
1645 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 &)){
1646         self->Connect( func );
1647       }
1648 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 &)){
1649         self->Disconnect( func );
1650       }
1651 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){
1652         return self->Emit( arg1, arg2 );
1653       }
1654 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1655          return self->Empty();
1656       }
1657 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1658         return self->GetConnectionCount();
1659       }
1660 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)){
1661           self->Connect( func );
1662       }
1663 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)){
1664           self->Disconnect( func );
1665       }
1666 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1667           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1668 /*@SWIG@*/ self->Emit( arg );
1669       }
1670 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1671          return self->Empty();
1672       }
1673 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1674         return self->GetConnectionCount();
1675       }
1676 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 &)){
1677           self->Connect( func );
1678       }
1679 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 &)){
1680           self->Disconnect( func );
1681       }
1682 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){
1683           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1684 /*@SWIG@*/ self->Emit( arg );
1685       }
1686 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1687          return self->Empty();
1688       }
1689 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){
1690         return self->GetConnectionCount();
1691       }
1692 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)){
1693         self->Connect( func );
1694       }
1695 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)){
1696         self->Disconnect( func );
1697       }
1698 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){
1699         return self->Emit( arg1, arg2 );
1700       }
1701 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1702          return self->Empty();
1703       }
1704 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){
1705         return self->GetConnectionCount();
1706       }
1707 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)){
1708         self->Connect( func );
1709       }
1710 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)){
1711         self->Disconnect( func );
1712       }
1713 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){
1714         return self->Emit( arg1, arg2 );
1715       }
1716
1717
1718 /* ---------------------------------------------------
1719  * C++ director class methods
1720  * --------------------------------------------------- */
1721
1722 #include "dali_wrap.h"
1723
1724 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1725   swig_init_callbacks();
1726 }
1727
1728 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1729
1730 }
1731
1732
1733 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1734   int jdepth  ;
1735
1736   if (!swig_callbackOnStageConnection) {
1737     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1738     return;
1739   } else {
1740     jdepth = depth;
1741     swig_callbackOnStageConnection(jdepth);
1742   }
1743 }
1744
1745 void SwigDirector_ViewImpl::OnStageDisconnection() {
1746   if (!swig_callbackOnStageDisconnection) {
1747     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1748     return;
1749   } else {
1750     swig_callbackOnStageDisconnection();
1751   }
1752 }
1753
1754 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1755   void * jchild = 0 ;
1756
1757   if (!swig_callbackOnChildAdd) {
1758     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1759     return;
1760   } else {
1761     jchild = (Dali::Actor *) &child;
1762     swig_callbackOnChildAdd(jchild);
1763   }
1764 }
1765
1766 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1767   void * jchild = 0 ;
1768
1769   if (!swig_callbackOnChildRemove) {
1770     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1771     return;
1772   } else {
1773     jchild = (Dali::Actor *) &child;
1774     swig_callbackOnChildRemove(jchild);
1775   }
1776 }
1777
1778 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1779   int jindex  ;
1780   void * jpropertyValue  ;
1781
1782   if (!swig_callbackOnPropertySet) {
1783     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1784     return;
1785   } else {
1786     jindex = index;
1787     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1788     swig_callbackOnPropertySet(jindex, jpropertyValue);
1789   }
1790 }
1791
1792 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1793   void * jtargetSize = 0 ;
1794
1795   if (!swig_callbackOnSizeSet) {
1796     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1797     return;
1798   } else {
1799     jtargetSize = (Dali::Vector3 *) &targetSize;
1800     swig_callbackOnSizeSet(jtargetSize);
1801   }
1802 }
1803
1804 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1805   void * janimation = 0 ;
1806   void * jtargetSize = 0 ;
1807
1808   if (!swig_callbackOnSizeAnimation) {
1809     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1810     return;
1811   } else {
1812     janimation = (Dali::Animation *) &animation;
1813     jtargetSize = (Dali::Vector3 *) &targetSize;
1814     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1815   }
1816 }
1817
1818 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1819   bool c_result = SwigValueInit< bool >() ;
1820   unsigned int jresult = 0 ;
1821   void * jarg0 = 0 ;
1822
1823   if (!swig_callbackOnTouchEvent) {
1824     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1825   } else {
1826     jarg0 = (Dali::TouchEvent *) &event;
1827     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1828     c_result = jresult ? true : false;
1829   }
1830   return c_result;
1831 }
1832
1833 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1834   bool c_result = SwigValueInit< bool >() ;
1835   unsigned int jresult = 0 ;
1836   void * jarg0 = 0 ;
1837
1838   if (!swig_callbackOnHoverEvent) {
1839     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1840   } else {
1841     jarg0 = (Dali::HoverEvent *) &event;
1842     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1843     c_result = jresult ? true : false;
1844   }
1845   return c_result;
1846 }
1847
1848 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1849   bool c_result = SwigValueInit< bool >() ;
1850   unsigned int jresult = 0 ;
1851   void * jarg0 = 0 ;
1852
1853   if (!swig_callbackOnKeyEvent) {
1854     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1855   } else {
1856     jarg0 = (Dali::KeyEvent *) &event;
1857     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1858     c_result = jresult ? true : false;
1859   }
1860   return c_result;
1861 }
1862
1863 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1864   bool c_result = SwigValueInit< bool >() ;
1865   unsigned int jresult = 0 ;
1866   void * jarg0 = 0 ;
1867
1868   if (!swig_callbackOnWheelEvent) {
1869     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1870   } else {
1871     jarg0 = (Dali::WheelEvent *) &event;
1872     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1873     c_result = jresult ? true : false;
1874   }
1875   return c_result;
1876 }
1877
1878 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1879   void * jsize = 0 ;
1880   void * jcontainer = 0 ;
1881
1882   if (!swig_callbackOnRelayout) {
1883     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1884     return;
1885   } else {
1886     jsize = (Dali::Vector2 *) &size;
1887     jcontainer = (Dali::RelayoutContainer *) &container;
1888     swig_callbackOnRelayout(jsize, jcontainer);
1889   }
1890 }
1891
1892 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1893   int jpolicy  ;
1894   int jdimension  ;
1895
1896   if (!swig_callbackOnSetResizePolicy) {
1897     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1898     return;
1899   } else {
1900     jpolicy = (int)policy;
1901     jdimension = (int)dimension;
1902     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1903   }
1904 }
1905
1906 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1907   Dali::Vector3 c_result ;
1908   void * jresult = 0 ;
1909
1910   if (!swig_callbackGetNaturalSize) {
1911     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1912   } else {
1913     jresult = (void *) swig_callbackGetNaturalSize();
1914     if (!jresult) {
1915       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1916       return c_result;
1917     }
1918     c_result = *(Dali::Vector3 *)jresult;
1919   }
1920   return c_result;
1921 }
1922
1923 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1924   float c_result = SwigValueInit< float >() ;
1925   float jresult = 0 ;
1926   void * jchild = 0 ;
1927   int jdimension  ;
1928
1929   if (!swig_callbackCalculateChildSize) {
1930     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1931   } else {
1932     jchild = (Dali::Actor *) &child;
1933     jdimension = (int)dimension;
1934     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1935     c_result = (float)jresult;
1936   }
1937   return c_result;
1938 }
1939
1940 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1941   float c_result = SwigValueInit< float >() ;
1942   float jresult = 0 ;
1943   float jwidth  ;
1944
1945   if (!swig_callbackGetHeightForWidth) {
1946     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1947   } else {
1948     jwidth = width;
1949     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1950     c_result = (float)jresult;
1951   }
1952   return c_result;
1953 }
1954
1955 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1956   float c_result = SwigValueInit< float >() ;
1957   float jresult = 0 ;
1958   float jheight  ;
1959
1960   if (!swig_callbackGetWidthForHeight) {
1961     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1962   } else {
1963     jheight = height;
1964     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1965     c_result = (float)jresult;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   int jdimension  ;
1974
1975   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1976     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1977   } else {
1978     jdimension = (int)dimension;
1979     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1986   int jdimension  ;
1987
1988   if (!swig_callbackOnCalculateRelayoutSize) {
1989     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1990     return;
1991   } else {
1992     jdimension = (int)dimension;
1993     swig_callbackOnCalculateRelayoutSize(jdimension);
1994   }
1995 }
1996
1997 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1998   float jsize  ;
1999   int jdimension  ;
2000
2001   if (!swig_callbackOnLayoutNegotiated) {
2002     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2003     return;
2004   } else {
2005     jsize = size;
2006     jdimension = (int)dimension;
2007     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2008   }
2009 }
2010
2011 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2012   return Dali::CustomActorImpl::GetExtension();
2013 }
2014
2015 void SwigDirector_ViewImpl::OnInitialize() {
2016   if (!swig_callbackOnInitialize) {
2017     Dali::Toolkit::Internal::Control::OnInitialize();
2018     return;
2019   } else {
2020     swig_callbackOnInitialize();
2021   }
2022 }
2023
2024 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2025   void * jchild = 0 ;
2026
2027   if (!swig_callbackOnControlChildAdd) {
2028     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2029     return;
2030   } else {
2031     jchild = (Dali::Actor *) &child;
2032     swig_callbackOnControlChildAdd(jchild);
2033   }
2034 }
2035
2036 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2037   void * jchild = 0 ;
2038
2039   if (!swig_callbackOnControlChildRemove) {
2040     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2041     return;
2042   } else {
2043     jchild = (Dali::Actor *) &child;
2044     swig_callbackOnControlChildRemove(jchild);
2045   }
2046 }
2047
2048 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2049   void * jstyleManager  ;
2050   int jchange  ;
2051
2052   if (!swig_callbackOnStyleChange) {
2053     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2054     return;
2055   } else {
2056     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2057     jchange = (int)change;
2058     swig_callbackOnStyleChange(jstyleManager, jchange);
2059   }
2060 }
2061
2062 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2063   bool c_result = SwigValueInit< bool >() ;
2064   unsigned int jresult = 0 ;
2065
2066   if (!swig_callbackOnAccessibilityActivated) {
2067     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2068   } else {
2069     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2070     c_result = jresult ? true : false;
2071   }
2072   return c_result;
2073 }
2074
2075 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2076   bool c_result = SwigValueInit< bool >() ;
2077   unsigned int jresult = 0 ;
2078   void * jgesture  ;
2079
2080   if (!swig_callbackOnAccessibilityPan) {
2081     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2082   } else {
2083     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2084     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2085     c_result = jresult ? true : false;
2086   }
2087   return c_result;
2088 }
2089
2090 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2091   bool c_result = SwigValueInit< bool >() ;
2092   unsigned int jresult = 0 ;
2093   void * jtouchEvent = 0 ;
2094
2095   if (!swig_callbackOnAccessibilityTouch) {
2096     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2097   } else {
2098     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2099     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2100     c_result = jresult ? true : false;
2101   }
2102   return c_result;
2103 }
2104
2105 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2106   bool c_result = SwigValueInit< bool >() ;
2107   unsigned int jresult = 0 ;
2108   unsigned int jisIncrease  ;
2109
2110   if (!swig_callbackOnAccessibilityValueChange) {
2111     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2112   } else {
2113     jisIncrease = isIncrease;
2114     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2115     c_result = jresult ? true : false;
2116   }
2117   return c_result;
2118 }
2119
2120 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2121   bool c_result = SwigValueInit< bool >() ;
2122   unsigned int jresult = 0 ;
2123
2124   if (!swig_callbackOnAccessibilityZoom) {
2125     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2126   } else {
2127     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2128     c_result = jresult ? true : false;
2129   }
2130   return c_result;
2131 }
2132
2133 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2134   if (!swig_callbackOnKeyInputFocusGained) {
2135     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2136     return;
2137   } else {
2138     swig_callbackOnKeyInputFocusGained();
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2143   if (!swig_callbackOnKeyInputFocusLost) {
2144     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2145     return;
2146   } else {
2147     swig_callbackOnKeyInputFocusLost();
2148   }
2149 }
2150
2151 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2152   Dali::Actor c_result ;
2153   void * jresult = 0 ;
2154   void * jcurrentFocusedActor  ;
2155   int jdirection  ;
2156   unsigned int jloopEnabled  ;
2157
2158   if (!swig_callbackGetNextKeyboardFocusableActor) {
2159     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2160   } else {
2161     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2162     jdirection = (int)direction;
2163     jloopEnabled = loopEnabled;
2164     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2165     if (!jresult) {
2166       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2167       return c_result;
2168     }
2169     c_result = *(Dali::Actor *)jresult;
2170   }
2171   return c_result;
2172 }
2173
2174 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2175   void * jcommitedFocusableActor  ;
2176
2177   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2178     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2179     return;
2180   } else {
2181     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2182     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2183   }
2184 }
2185
2186 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2187   bool c_result = SwigValueInit< bool >() ;
2188   unsigned int jresult = 0 ;
2189
2190   if (!swig_callbackOnKeyboardEnter) {
2191     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2192   } else {
2193     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2200   void * jpinch = 0 ;
2201
2202   if (!swig_callbackOnPinch) {
2203     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2204     return;
2205   } else {
2206     jpinch = (Dali::PinchGesture *) &pinch;
2207     swig_callbackOnPinch(jpinch);
2208   }
2209 }
2210
2211 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2212   void * jpan = 0 ;
2213
2214   if (!swig_callbackOnPan) {
2215     Dali::Toolkit::Internal::Control::OnPan(pan);
2216     return;
2217   } else {
2218     jpan = (Dali::PanGesture *) &pan;
2219     swig_callbackOnPan(jpan);
2220   }
2221 }
2222
2223 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2224   void * jtap = 0 ;
2225
2226   if (!swig_callbackOnTap) {
2227     Dali::Toolkit::Internal::Control::OnTap(tap);
2228     return;
2229   } else {
2230     jtap = (Dali::TapGesture *) &tap;
2231     swig_callbackOnTap(jtap);
2232   }
2233 }
2234
2235 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2236   void * jlongPress = 0 ;
2237
2238   if (!swig_callbackOnLongPress) {
2239     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2240     return;
2241   } else {
2242     jlongPress = (Dali::LongPressGesture *) &longPress;
2243     swig_callbackOnLongPress(jlongPress);
2244   }
2245 }
2246
2247 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2248   void * jslotObserver = 0 ;
2249   void * jcallback = 0 ;
2250
2251   if (!swig_callbackSignalConnected) {
2252     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2253     return;
2254   } else {
2255     jslotObserver = (void *) slotObserver;
2256     jcallback = (void *) callback;
2257     swig_callbackSignalConnected(jslotObserver, jcallback);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2262   void * jslotObserver = 0 ;
2263   void * jcallback = 0 ;
2264
2265   if (!swig_callbackSignalDisconnected) {
2266     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2267     return;
2268   } else {
2269     jslotObserver = (void *) slotObserver;
2270     jcallback = (void *) callback;
2271     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2272   }
2273 }
2274
2275 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2276   return Dali::Toolkit::Internal::Control::GetControlExtension();
2277 }
2278
2279 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) {
2280   swig_callbackOnStageConnection = callbackOnStageConnection;
2281   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2282   swig_callbackOnChildAdd = callbackOnChildAdd;
2283   swig_callbackOnChildRemove = callbackOnChildRemove;
2284   swig_callbackOnPropertySet = callbackOnPropertySet;
2285   swig_callbackOnSizeSet = callbackOnSizeSet;
2286   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2287   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2288   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2289   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2290   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2291   swig_callbackOnRelayout = callbackOnRelayout;
2292   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2293   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2294   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2295   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2296   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2297   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2298   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2299   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2300   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2301   swig_callbackOnInitialize = callbackOnInitialize;
2302   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2303   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2304   swig_callbackOnStyleChange = callbackOnStyleChange;
2305   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2306   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2307   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2308   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2309   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2310   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2311   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2312   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2313   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2314   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2315   swig_callbackOnPinch = callbackOnPinch;
2316   swig_callbackOnPan = callbackOnPan;
2317   swig_callbackOnTap = callbackOnTap;
2318   swig_callbackOnLongPress = callbackOnLongPress;
2319   swig_callbackSignalConnected = callbackSignalConnected;
2320   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2321 }
2322
2323 void SwigDirector_ViewImpl::swig_init_callbacks() {
2324   swig_callbackOnStageConnection = 0;
2325   swig_callbackOnStageDisconnection = 0;
2326   swig_callbackOnChildAdd = 0;
2327   swig_callbackOnChildRemove = 0;
2328   swig_callbackOnPropertySet = 0;
2329   swig_callbackOnSizeSet = 0;
2330   swig_callbackOnSizeAnimation = 0;
2331   swig_callbackOnTouchEvent = 0;
2332   swig_callbackOnHoverEvent = 0;
2333   swig_callbackOnKeyEvent = 0;
2334   swig_callbackOnWheelEvent = 0;
2335   swig_callbackOnRelayout = 0;
2336   swig_callbackOnSetResizePolicy = 0;
2337   swig_callbackGetNaturalSize = 0;
2338   swig_callbackCalculateChildSize = 0;
2339   swig_callbackGetHeightForWidth = 0;
2340   swig_callbackGetWidthForHeight = 0;
2341   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2342   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2343   swig_callbackOnCalculateRelayoutSize = 0;
2344   swig_callbackOnLayoutNegotiated = 0;
2345   swig_callbackOnInitialize = 0;
2346   swig_callbackOnControlChildAdd = 0;
2347   swig_callbackOnControlChildRemove = 0;
2348   swig_callbackOnStyleChange = 0;
2349   swig_callbackOnAccessibilityActivated = 0;
2350   swig_callbackOnAccessibilityPan = 0;
2351   swig_callbackOnAccessibilityTouch = 0;
2352   swig_callbackOnAccessibilityValueChange = 0;
2353   swig_callbackOnAccessibilityZoom = 0;
2354   swig_callbackOnKeyInputFocusGained = 0;
2355   swig_callbackOnKeyInputFocusLost = 0;
2356   swig_callbackGetNextKeyboardFocusableActor = 0;
2357   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2358   swig_callbackOnKeyboardEnter = 0;
2359   swig_callbackOnPinch = 0;
2360   swig_callbackOnPan = 0;
2361   swig_callbackOnTap = 0;
2362   swig_callbackOnLongPress = 0;
2363   swig_callbackSignalConnected = 0;
2364   swig_callbackSignalDisconnected = 0;
2365 }
2366
2367 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2368   swig_init_callbacks();
2369 }
2370
2371 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2372
2373 }
2374
2375
2376 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2377   unsigned int c_result = SwigValueInit< unsigned int >() ;
2378   unsigned int jresult = 0 ;
2379
2380   if (!swig_callbackGetNumberOfItems) {
2381     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2382   } else {
2383     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2384     c_result = (unsigned int)jresult;
2385   }
2386   return c_result;
2387 }
2388
2389 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2390   Dali::Actor c_result ;
2391   void * jresult = 0 ;
2392   unsigned int jitemId  ;
2393
2394   if (!swig_callbackNewItem) {
2395     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2396   } else {
2397     jitemId = itemId;
2398     jresult = (void *) swig_callbackNewItem(jitemId);
2399     if (!jresult) {
2400       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2401       return c_result;
2402     }
2403     c_result = *(Dali::Actor *)jresult;
2404   }
2405   return c_result;
2406 }
2407
2408 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2409   unsigned int jitemId  ;
2410   void * jactor  ;
2411
2412   if (!swig_callbackItemReleased) {
2413     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2414     return;
2415   } else {
2416     jitemId = itemId;
2417     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2418     swig_callbackItemReleased(jitemId, jactor);
2419   }
2420 }
2421
2422 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2423   return Dali::Toolkit::ItemFactory::GetExtension();
2424 }
2425
2426 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2427   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2428   swig_callbackNewItem = callbackNewItem;
2429   swig_callbackItemReleased = callbackItemReleased;
2430 }
2431
2432 void SwigDirector_ItemFactory::swig_init_callbacks() {
2433   swig_callbackGetNumberOfItems = 0;
2434   swig_callbackNewItem = 0;
2435   swig_callbackItemReleased = 0;
2436 }
2437
2438 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2439   swig_init_callbacks();
2440 }
2441
2442 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2443
2444 }
2445
2446
2447 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2448   Dali::Actor c_result ;
2449   void * jresult = 0 ;
2450   void * jcurrent  ;
2451   void * jproposed  ;
2452   int jdirection  ;
2453
2454   if (!swig_callbackGetNextFocusableActor) {
2455     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2456   } else {
2457     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2458     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2459     jdirection = (int)direction;
2460     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2461     if (!jresult) {
2462       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2463       return c_result;
2464     }
2465     c_result = *(Dali::Actor *)jresult;
2466   }
2467   return c_result;
2468 }
2469
2470 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2471   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2472 }
2473
2474 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2475   swig_callbackGetNextFocusableActor = 0;
2476 }
2477
2478
2479 #ifdef __cplusplus
2480 extern "C" {
2481 #endif
2482
2483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2484   void * jresult ;
2485   floatp *result = 0 ;
2486
2487   {
2488     try {
2489       result = (floatp *)new_floatp();
2490     } catch (std::out_of_range& e) {
2491       {
2492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2493       };
2494     } catch (std::exception& e) {
2495       {
2496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2497       };
2498     } catch (...) {
2499       {
2500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2501       };
2502     }
2503   }
2504   jresult = (void *)result;
2505   return jresult;
2506 }
2507
2508
2509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2510   floatp *arg1 = (floatp *) 0 ;
2511
2512   arg1 = (floatp *)jarg1;
2513   {
2514     try {
2515       delete_floatp(arg1);
2516     } catch (std::out_of_range& e) {
2517       {
2518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2519       };
2520     } catch (std::exception& e) {
2521       {
2522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2523       };
2524     } catch (...) {
2525       {
2526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2527       };
2528     }
2529   }
2530 }
2531
2532
2533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2534   floatp *arg1 = (floatp *) 0 ;
2535   float arg2 ;
2536
2537   arg1 = (floatp *)jarg1;
2538   arg2 = (float)jarg2;
2539   {
2540     try {
2541       floatp_assign(arg1,arg2);
2542     } catch (std::out_of_range& e) {
2543       {
2544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2545       };
2546     } catch (std::exception& e) {
2547       {
2548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2549       };
2550     } catch (...) {
2551       {
2552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2553       };
2554     }
2555   }
2556 }
2557
2558
2559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2560   float jresult ;
2561   floatp *arg1 = (floatp *) 0 ;
2562   float result;
2563
2564   arg1 = (floatp *)jarg1;
2565   {
2566     try {
2567       result = (float)floatp_value(arg1);
2568     } catch (std::out_of_range& e) {
2569       {
2570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2571       };
2572     } catch (std::exception& e) {
2573       {
2574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2575       };
2576     } catch (...) {
2577       {
2578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2579       };
2580     }
2581   }
2582   jresult = result;
2583   return jresult;
2584 }
2585
2586
2587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2588   void * jresult ;
2589   floatp *arg1 = (floatp *) 0 ;
2590   float *result = 0 ;
2591
2592   arg1 = (floatp *)jarg1;
2593   {
2594     try {
2595       result = (float *)floatp_cast(arg1);
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (...) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2607       };
2608     }
2609   }
2610   jresult = (void *)result;
2611   return jresult;
2612 }
2613
2614
2615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2616   void * jresult ;
2617   float *arg1 = (float *) 0 ;
2618   floatp *result = 0 ;
2619
2620   arg1 = (float *)jarg1;
2621   {
2622     try {
2623       result = (floatp *)floatp_frompointer(arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (...) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2635       };
2636     }
2637   }
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2644   void * jresult ;
2645   intp *result = 0 ;
2646
2647   {
2648     try {
2649       result = (intp *)new_intp();
2650     } catch (std::out_of_range& e) {
2651       {
2652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2653       };
2654     } catch (std::exception& e) {
2655       {
2656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2657       };
2658     } catch (...) {
2659       {
2660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2661       };
2662     }
2663   }
2664   jresult = (void *)result;
2665   return jresult;
2666 }
2667
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2670   intp *arg1 = (intp *) 0 ;
2671
2672   arg1 = (intp *)jarg1;
2673   {
2674     try {
2675       delete_intp(arg1);
2676     } catch (std::out_of_range& e) {
2677       {
2678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2679       };
2680     } catch (std::exception& e) {
2681       {
2682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2683       };
2684     } catch (...) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2687       };
2688     }
2689   }
2690 }
2691
2692
2693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2694   intp *arg1 = (intp *) 0 ;
2695   int arg2 ;
2696
2697   arg1 = (intp *)jarg1;
2698   arg2 = (int)jarg2;
2699   {
2700     try {
2701       intp_assign(arg1,arg2);
2702     } catch (std::out_of_range& e) {
2703       {
2704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2705       };
2706     } catch (std::exception& e) {
2707       {
2708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2709       };
2710     } catch (...) {
2711       {
2712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2713       };
2714     }
2715   }
2716 }
2717
2718
2719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2720   int jresult ;
2721   intp *arg1 = (intp *) 0 ;
2722   int result;
2723
2724   arg1 = (intp *)jarg1;
2725   {
2726     try {
2727       result = (int)intp_value(arg1);
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (...) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2739       };
2740     }
2741   }
2742   jresult = result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2748   void * jresult ;
2749   intp *arg1 = (intp *) 0 ;
2750   int *result = 0 ;
2751
2752   arg1 = (intp *)jarg1;
2753   {
2754     try {
2755       result = (int *)intp_cast(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (...) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2767       };
2768     }
2769   }
2770   jresult = (void *)result;
2771   return jresult;
2772 }
2773
2774
2775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2776   void * jresult ;
2777   int *arg1 = (int *) 0 ;
2778   intp *result = 0 ;
2779
2780   arg1 = (int *)jarg1;
2781   {
2782     try {
2783       result = (intp *)intp_frompointer(arg1);
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (...) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2795       };
2796     }
2797   }
2798   jresult = (void *)result;
2799   return jresult;
2800 }
2801
2802
2803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2804   void * jresult ;
2805   doublep *result = 0 ;
2806
2807   {
2808     try {
2809       result = (doublep *)new_doublep();
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2817       };
2818     } catch (...) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2821       };
2822     }
2823   }
2824   jresult = (void *)result;
2825   return jresult;
2826 }
2827
2828
2829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2830   doublep *arg1 = (doublep *) 0 ;
2831
2832   arg1 = (doublep *)jarg1;
2833   {
2834     try {
2835       delete_doublep(arg1);
2836     } catch (std::out_of_range& e) {
2837       {
2838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2839       };
2840     } catch (std::exception& e) {
2841       {
2842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (...) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2847       };
2848     }
2849   }
2850 }
2851
2852
2853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2854   doublep *arg1 = (doublep *) 0 ;
2855   double arg2 ;
2856
2857   arg1 = (doublep *)jarg1;
2858   arg2 = (double)jarg2;
2859   {
2860     try {
2861       doublep_assign(arg1,arg2);
2862     } catch (std::out_of_range& e) {
2863       {
2864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2865       };
2866     } catch (std::exception& e) {
2867       {
2868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2869       };
2870     } catch (...) {
2871       {
2872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2873       };
2874     }
2875   }
2876 }
2877
2878
2879 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2880   double jresult ;
2881   doublep *arg1 = (doublep *) 0 ;
2882   double result;
2883
2884   arg1 = (doublep *)jarg1;
2885   {
2886     try {
2887       result = (double)doublep_value(arg1);
2888     } catch (std::out_of_range& e) {
2889       {
2890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2891       };
2892     } catch (std::exception& e) {
2893       {
2894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2895       };
2896     } catch (...) {
2897       {
2898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2899       };
2900     }
2901   }
2902   jresult = result;
2903   return jresult;
2904 }
2905
2906
2907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2908   void * jresult ;
2909   doublep *arg1 = (doublep *) 0 ;
2910   double *result = 0 ;
2911
2912   arg1 = (doublep *)jarg1;
2913   {
2914     try {
2915       result = (double *)doublep_cast(arg1);
2916     } catch (std::out_of_range& e) {
2917       {
2918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2919       };
2920     } catch (std::exception& e) {
2921       {
2922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2923       };
2924     } catch (...) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2927       };
2928     }
2929   }
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2936   void * jresult ;
2937   double *arg1 = (double *) 0 ;
2938   doublep *result = 0 ;
2939
2940   arg1 = (double *)jarg1;
2941   {
2942     try {
2943       result = (doublep *)doublep_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (...) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2955       };
2956     }
2957   }
2958   jresult = (void *)result;
2959   return jresult;
2960 }
2961
2962
2963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2964   void * jresult ;
2965   uintp *result = 0 ;
2966
2967   {
2968     try {
2969       result = (uintp *)new_uintp();
2970     } catch (std::out_of_range& e) {
2971       {
2972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2973       };
2974     } catch (std::exception& e) {
2975       {
2976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (...) {
2979       {
2980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2981       };
2982     }
2983   }
2984   jresult = (void *)result;
2985   return jresult;
2986 }
2987
2988
2989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2990   uintp *arg1 = (uintp *) 0 ;
2991
2992   arg1 = (uintp *)jarg1;
2993   {
2994     try {
2995       delete_uintp(arg1);
2996     } catch (std::out_of_range& e) {
2997       {
2998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (std::exception& e) {
3001       {
3002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010 }
3011
3012
3013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3014   uintp *arg1 = (uintp *) 0 ;
3015   unsigned int arg2 ;
3016
3017   arg1 = (uintp *)jarg1;
3018   arg2 = (unsigned int)jarg2;
3019   {
3020     try {
3021       uintp_assign(arg1,arg2);
3022     } catch (std::out_of_range& e) {
3023       {
3024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3025       };
3026     } catch (std::exception& e) {
3027       {
3028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3029       };
3030     } catch (...) {
3031       {
3032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3033       };
3034     }
3035   }
3036 }
3037
3038
3039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3040   unsigned int jresult ;
3041   uintp *arg1 = (uintp *) 0 ;
3042   unsigned int result;
3043
3044   arg1 = (uintp *)jarg1;
3045   {
3046     try {
3047       result = (unsigned int)uintp_value(arg1);
3048     } catch (std::out_of_range& e) {
3049       {
3050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3051       };
3052     } catch (std::exception& e) {
3053       {
3054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3059       };
3060     }
3061   }
3062   jresult = result;
3063   return jresult;
3064 }
3065
3066
3067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3068   void * jresult ;
3069   uintp *arg1 = (uintp *) 0 ;
3070   unsigned int *result = 0 ;
3071
3072   arg1 = (uintp *)jarg1;
3073   {
3074     try {
3075       result = (unsigned int *)uintp_cast(arg1);
3076     } catch (std::out_of_range& e) {
3077       {
3078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3079       };
3080     } catch (std::exception& e) {
3081       {
3082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3083       };
3084     } catch (...) {
3085       {
3086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3087       };
3088     }
3089   }
3090   jresult = (void *)result;
3091   return jresult;
3092 }
3093
3094
3095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3096   void * jresult ;
3097   unsigned int *arg1 = (unsigned int *) 0 ;
3098   uintp *result = 0 ;
3099
3100   arg1 = (unsigned int *)jarg1;
3101   {
3102     try {
3103       result = (uintp *)uintp_frompointer(arg1);
3104     } catch (std::out_of_range& e) {
3105       {
3106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (std::exception& e) {
3109       {
3110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118   jresult = (void *)result;
3119   return jresult;
3120 }
3121
3122
3123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3124   void * jresult ;
3125   ushortp *result = 0 ;
3126
3127   {
3128     try {
3129       result = (ushortp *)new_ushortp();
3130     } catch (std::out_of_range& e) {
3131       {
3132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (std::exception& e) {
3135       {
3136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (...) {
3139       {
3140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3141       };
3142     }
3143   }
3144   jresult = (void *)result;
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3150   ushortp *arg1 = (ushortp *) 0 ;
3151
3152   arg1 = (ushortp *)jarg1;
3153   {
3154     try {
3155       delete_ushortp(arg1);
3156     } catch (std::out_of_range& e) {
3157       {
3158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3159       };
3160     } catch (std::exception& e) {
3161       {
3162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3163       };
3164     } catch (...) {
3165       {
3166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3167       };
3168     }
3169   }
3170 }
3171
3172
3173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3174   ushortp *arg1 = (ushortp *) 0 ;
3175   unsigned short arg2 ;
3176
3177   arg1 = (ushortp *)jarg1;
3178   arg2 = (unsigned short)jarg2;
3179   {
3180     try {
3181       ushortp_assign(arg1,arg2);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (...) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3193       };
3194     }
3195   }
3196 }
3197
3198
3199 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3200   unsigned short jresult ;
3201   ushortp *arg1 = (ushortp *) 0 ;
3202   unsigned short result;
3203
3204   arg1 = (ushortp *)jarg1;
3205   {
3206     try {
3207       result = (unsigned short)ushortp_value(arg1);
3208     } catch (std::out_of_range& e) {
3209       {
3210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3211       };
3212     } catch (std::exception& e) {
3213       {
3214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (...) {
3217       {
3218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3219       };
3220     }
3221   }
3222   jresult = result;
3223   return jresult;
3224 }
3225
3226
3227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3228   void * jresult ;
3229   ushortp *arg1 = (ushortp *) 0 ;
3230   unsigned short *result = 0 ;
3231
3232   arg1 = (ushortp *)jarg1;
3233   {
3234     try {
3235       result = (unsigned short *)ushortp_cast(arg1);
3236     } catch (std::out_of_range& e) {
3237       {
3238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3239       };
3240     } catch (std::exception& e) {
3241       {
3242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3243       };
3244     } catch (...) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3247       };
3248     }
3249   }
3250   jresult = (void *)result;
3251   return jresult;
3252 }
3253
3254
3255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3256   void * jresult ;
3257   unsigned short *arg1 = (unsigned short *) 0 ;
3258   ushortp *result = 0 ;
3259
3260   arg1 = (unsigned short *)jarg1;
3261   {
3262     try {
3263       result = (ushortp *)ushortp_frompointer(arg1);
3264     } catch (std::out_of_range& e) {
3265       {
3266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (std::exception& e) {
3269       {
3270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278   jresult = (void *)result;
3279   return jresult;
3280 }
3281
3282
3283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3284   unsigned int jresult ;
3285   int arg1 ;
3286   unsigned int result;
3287
3288   arg1 = (int)jarg1;
3289   {
3290     try {
3291       result = (unsigned int)int_to_uint(arg1);
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3312   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3313
3314   arg1 = (Dali::RefObject *)jarg1;
3315   {
3316     try {
3317       (arg1)->Reference();
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (...) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3329       };
3330     }
3331   }
3332 }
3333
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3336   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3337
3338   arg1 = (Dali::RefObject *)jarg1;
3339   {
3340     try {
3341       (arg1)->Unreference();
3342     } catch (std::out_of_range& e) {
3343       {
3344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (std::exception& e) {
3347       {
3348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3349       };
3350     } catch (...) {
3351       {
3352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3353       };
3354     }
3355   }
3356 }
3357
3358
3359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3360   int jresult ;
3361   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3362   int result;
3363
3364   arg1 = (Dali::RefObject *)jarg1;
3365   {
3366     try {
3367       result = (int)(arg1)->ReferenceCount();
3368     } catch (std::out_of_range& e) {
3369       {
3370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3371       };
3372     } catch (std::exception& e) {
3373       {
3374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3375       };
3376     } catch (...) {
3377       {
3378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3379       };
3380     }
3381   }
3382   jresult = result;
3383   return jresult;
3384 }
3385
3386
3387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3388   void * jresult ;
3389   Dali::Any *result = 0 ;
3390
3391   {
3392     try {
3393       result = (Dali::Any *)new Dali::Any();
3394     } catch (std::out_of_range& e) {
3395       {
3396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3397       };
3398     } catch (std::exception& e) {
3399       {
3400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3401       };
3402     } catch (...) {
3403       {
3404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3405       };
3406     }
3407   }
3408   jresult = (void *)result;
3409   return jresult;
3410 }
3411
3412
3413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3414   Dali::Any *arg1 = (Dali::Any *) 0 ;
3415
3416   arg1 = (Dali::Any *)jarg1;
3417   {
3418     try {
3419       delete arg1;
3420     } catch (std::out_of_range& e) {
3421       {
3422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (std::exception& e) {
3425       {
3426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434 }
3435
3436
3437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3438   char *arg1 = (char *) 0 ;
3439
3440   arg1 = (char *)jarg1;
3441   {
3442     try {
3443       Dali::Any::AssertAlways((char const *)arg1);
3444     } catch (std::out_of_range& e) {
3445       {
3446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3447       };
3448     } catch (std::exception& e) {
3449       {
3450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3451       };
3452     } catch (...) {
3453       {
3454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3455       };
3456     }
3457   }
3458 }
3459
3460
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3462   void * jresult ;
3463   Dali::Any *arg1 = 0 ;
3464   Dali::Any *result = 0 ;
3465
3466   arg1 = (Dali::Any *)jarg1;
3467   if (!arg1) {
3468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3469     return 0;
3470   }
3471   {
3472     try {
3473       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3474     } catch (std::out_of_range& e) {
3475       {
3476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (std::exception& e) {
3479       {
3480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3481       };
3482     } catch (...) {
3483       {
3484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3485       };
3486     }
3487   }
3488   jresult = (void *)result;
3489   return jresult;
3490 }
3491
3492
3493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3494   void * jresult ;
3495   Dali::Any *arg1 = (Dali::Any *) 0 ;
3496   Dali::Any *arg2 = 0 ;
3497   Dali::Any *result = 0 ;
3498
3499   arg1 = (Dali::Any *)jarg1;
3500   arg2 = (Dali::Any *)jarg2;
3501   if (!arg2) {
3502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3503     return 0;
3504   }
3505   {
3506     try {
3507       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3508     } catch (std::out_of_range& e) {
3509       {
3510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3511       };
3512     } catch (std::exception& e) {
3513       {
3514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (...) {
3517       {
3518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3519       };
3520     }
3521   }
3522   jresult = (void *)result;
3523   return jresult;
3524 }
3525
3526
3527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3528   void * jresult ;
3529   Dali::Any *arg1 = (Dali::Any *) 0 ;
3530   std::type_info *result = 0 ;
3531
3532   arg1 = (Dali::Any *)jarg1;
3533   {
3534     try {
3535       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3536     } catch (std::out_of_range& e) {
3537       {
3538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3539       };
3540     } catch (std::exception& e) {
3541       {
3542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (...) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3547       };
3548     }
3549   }
3550   jresult = (void *)result;
3551   return jresult;
3552 }
3553
3554
3555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3556   unsigned int jresult ;
3557   Dali::Any *arg1 = (Dali::Any *) 0 ;
3558   bool result;
3559
3560   arg1 = (Dali::Any *)jarg1;
3561   {
3562     try {
3563       result = (bool)((Dali::Any const *)arg1)->Empty();
3564     } catch (std::out_of_range& e) {
3565       {
3566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3567       };
3568     } catch (std::exception& e) {
3569       {
3570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3575       };
3576     }
3577   }
3578   jresult = result;
3579   return jresult;
3580 }
3581
3582
3583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3584   void * jresult ;
3585   std::type_info *arg1 = 0 ;
3586   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3587   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3588   Dali::Any::AnyContainerBase *result = 0 ;
3589
3590   arg1 = (std::type_info *)jarg1;
3591   if (!arg1) {
3592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3593     return 0;
3594   }
3595   arg2 = (Dali::Any::CloneFunc)jarg2;
3596   arg3 = (Dali::Any::DeleteFunc)jarg3;
3597   {
3598     try {
3599       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3600     } catch (std::out_of_range& e) {
3601       {
3602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3603       };
3604     } catch (std::exception& e) {
3605       {
3606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3607       };
3608     } catch (...) {
3609       {
3610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3611       };
3612     }
3613   }
3614   jresult = (void *)result;
3615   return jresult;
3616 }
3617
3618
3619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3620   void * jresult ;
3621   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3622   std::type_info *result = 0 ;
3623
3624   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3625   {
3626     try {
3627       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3628     } catch (std::out_of_range& e) {
3629       {
3630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (std::exception& e) {
3633       {
3634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3648   void * jresult ;
3649   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3650   ::std::type_info *result = 0 ;
3651
3652   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3653   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3654   jresult = (void *)result;
3655   return jresult;
3656 }
3657
3658
3659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3660   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3661   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3662
3663   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3664   arg2 = (Dali::Any::CloneFunc)jarg2;
3665   if (arg1) (arg1)->mCloneFunc = arg2;
3666 }
3667
3668
3669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3670   void * jresult ;
3671   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3672   Dali::Any::CloneFunc result;
3673
3674   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3675   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3676   jresult = (void *)result;
3677   return jresult;
3678 }
3679
3680
3681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3682   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3683   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3684
3685   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3686   arg2 = (Dali::Any::DeleteFunc)jarg2;
3687   if (arg1) (arg1)->mDeleteFunc = arg2;
3688 }
3689
3690
3691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3692   void * jresult ;
3693   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3694   Dali::Any::DeleteFunc result;
3695
3696   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3697   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3698   jresult = (void *)result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3704   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3705
3706   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3707   {
3708     try {
3709       delete arg1;
3710     } catch (std::out_of_range& e) {
3711       {
3712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3713       };
3714     } catch (std::exception& e) {
3715       {
3716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3717       };
3718     } catch (...) {
3719       {
3720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3721       };
3722     }
3723   }
3724 }
3725
3726
3727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3728   Dali::Any *arg1 = (Dali::Any *) 0 ;
3729   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3730
3731   arg1 = (Dali::Any *)jarg1;
3732   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3733   if (arg1) (arg1)->mContainer = arg2;
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3738   void * jresult ;
3739   Dali::Any *arg1 = (Dali::Any *) 0 ;
3740   Dali::Any::AnyContainerBase *result = 0 ;
3741
3742   arg1 = (Dali::Any *)jarg1;
3743   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3744   jresult = (void *)result;
3745   return jresult;
3746 }
3747
3748
3749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3750   char *arg1 = (char *) 0 ;
3751   char *arg2 = (char *) 0 ;
3752
3753   arg1 = (char *)jarg1;
3754   arg2 = (char *)jarg2;
3755   {
3756     try {
3757       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3765       };
3766     } catch (...) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3769       };
3770     }
3771   }
3772 }
3773
3774
3775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3776   void * jresult ;
3777   char *arg1 = (char *) 0 ;
3778   char *arg2 = (char *) 0 ;
3779   Dali::DaliException *result = 0 ;
3780
3781   arg1 = (char *)jarg1;
3782   arg2 = (char *)jarg2;
3783   {
3784     try {
3785       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3786     } catch (std::out_of_range& e) {
3787       {
3788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3789       };
3790     } catch (std::exception& e) {
3791       {
3792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3793       };
3794     } catch (...) {
3795       {
3796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3797       };
3798     }
3799   }
3800   jresult = (void *)result;
3801   return jresult;
3802 }
3803
3804
3805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3806   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3807   char *arg2 = (char *) 0 ;
3808
3809   arg1 = (Dali::DaliException *)jarg1;
3810   arg2 = (char *)jarg2;
3811   {
3812     if (arg2) {
3813       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3814       strcpy((char *)arg1->location, (const char *)arg2);
3815     } else {
3816       arg1->location = 0;
3817     }
3818   }
3819 }
3820
3821
3822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3823   char * jresult ;
3824   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3825   char *result = 0 ;
3826
3827   arg1 = (Dali::DaliException *)jarg1;
3828   result = (char *) ((arg1)->location);
3829   jresult = SWIG_csharp_string_callback((const char *)result);
3830   return jresult;
3831 }
3832
3833
3834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3835   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3836   char *arg2 = (char *) 0 ;
3837
3838   arg1 = (Dali::DaliException *)jarg1;
3839   arg2 = (char *)jarg2;
3840   {
3841     if (arg2) {
3842       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3843       strcpy((char *)arg1->condition, (const char *)arg2);
3844     } else {
3845       arg1->condition = 0;
3846     }
3847   }
3848 }
3849
3850
3851 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3852   char * jresult ;
3853   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3854   char *result = 0 ;
3855
3856   arg1 = (Dali::DaliException *)jarg1;
3857   result = (char *) ((arg1)->condition);
3858   jresult = SWIG_csharp_string_callback((const char *)result);
3859   return jresult;
3860 }
3861
3862
3863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3864   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3865
3866   arg1 = (Dali::DaliException *)jarg1;
3867   {
3868     try {
3869       delete arg1;
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3881       };
3882     }
3883   }
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3888   void * jresult ;
3889   Dali::Vector2 *result = 0 ;
3890
3891   {
3892     try {
3893       result = (Dali::Vector2 *)new Dali::Vector2();
3894     } catch (std::out_of_range& e) {
3895       {
3896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3897       };
3898     } catch (std::exception& e) {
3899       {
3900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (...) {
3903       {
3904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3905       };
3906     }
3907   }
3908   jresult = (void *)result;
3909   return jresult;
3910 }
3911
3912
3913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3914   void * jresult ;
3915   float arg1 ;
3916   float arg2 ;
3917   Dali::Vector2 *result = 0 ;
3918
3919   arg1 = (float)jarg1;
3920   arg2 = (float)jarg2;
3921   {
3922     try {
3923       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3924     } catch (std::out_of_range& e) {
3925       {
3926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3927       };
3928     } catch (std::exception& e) {
3929       {
3930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3931       };
3932     } catch (...) {
3933       {
3934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3935       };
3936     }
3937   }
3938   jresult = (void *)result;
3939   return jresult;
3940 }
3941
3942
3943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3944   void * jresult ;
3945   float *arg1 = (float *) 0 ;
3946   Dali::Vector2 *result = 0 ;
3947
3948   arg1 = jarg1;
3949   {
3950     try {
3951       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3952     } catch (std::out_of_range& e) {
3953       {
3954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3955       };
3956     } catch (std::exception& e) {
3957       {
3958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3959       };
3960     } catch (...) {
3961       {
3962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3963       };
3964     }
3965   }
3966   jresult = (void *)result;
3967
3968
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3974   void * jresult ;
3975   Dali::Vector3 *arg1 = 0 ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   arg1 = (Dali::Vector3 *)jarg1;
3979   if (!arg1) {
3980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3981     return 0;
3982   }
3983   {
3984     try {
3985       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3986     } catch (std::out_of_range& e) {
3987       {
3988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3989       };
3990     } catch (std::exception& e) {
3991       {
3992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3993       };
3994     } catch (...) {
3995       {
3996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3997       };
3998     }
3999   }
4000   jresult = (void *)result;
4001   return jresult;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4006   void * jresult ;
4007   Dali::Vector4 *arg1 = 0 ;
4008   Dali::Vector2 *result = 0 ;
4009
4010   arg1 = (Dali::Vector4 *)jarg1;
4011   if (!arg1) {
4012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4013     return 0;
4014   }
4015   {
4016     try {
4017       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4018     } catch (std::out_of_range& e) {
4019       {
4020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4021       };
4022     } catch (std::exception& e) {
4023       {
4024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4025       };
4026     } catch (...) {
4027       {
4028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4029       };
4030     }
4031   }
4032   jresult = (void *)result;
4033   return jresult;
4034 }
4035
4036
4037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4038   void * jresult ;
4039   Dali::Vector2 *result = 0 ;
4040
4041   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4042   jresult = (void *)result;
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4048   void * jresult ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4052   jresult = (void *)result;
4053   return jresult;
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4058   void * jresult ;
4059   Dali::Vector2 *result = 0 ;
4060
4061   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4062   jresult = (void *)result;
4063   return jresult;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4068   void * jresult ;
4069   Dali::Vector2 *result = 0 ;
4070
4071   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4072   jresult = (void *)result;
4073   return jresult;
4074 }
4075
4076
4077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4078   void * jresult ;
4079   Dali::Vector2 *result = 0 ;
4080
4081   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4082   jresult = (void *)result;
4083   return jresult;
4084 }
4085
4086
4087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4088   void * jresult ;
4089   Dali::Vector2 *result = 0 ;
4090
4091   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4092   jresult = (void *)result;
4093   return jresult;
4094 }
4095
4096
4097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4098   void * jresult ;
4099   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4100   float *arg2 = (float *) 0 ;
4101   Dali::Vector2 *result = 0 ;
4102
4103   arg1 = (Dali::Vector2 *)jarg1;
4104   arg2 = jarg2;
4105   {
4106     try {
4107       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4108     } catch (std::out_of_range& e) {
4109       {
4110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4111       };
4112     } catch (std::exception& e) {
4113       {
4114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4115       };
4116     } catch (...) {
4117       {
4118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4119       };
4120     }
4121   }
4122   jresult = (void *)result;
4123
4124
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4130   void * jresult ;
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   Dali::Vector3 *arg2 = 0 ;
4133   Dali::Vector2 *result = 0 ;
4134
4135   arg1 = (Dali::Vector2 *)jarg1;
4136   arg2 = (Dali::Vector3 *)jarg2;
4137   if (!arg2) {
4138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4139     return 0;
4140   }
4141   {
4142     try {
4143       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4144     } catch (std::out_of_range& e) {
4145       {
4146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4147       };
4148     } catch (std::exception& e) {
4149       {
4150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4151       };
4152     } catch (...) {
4153       {
4154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4155       };
4156     }
4157   }
4158   jresult = (void *)result;
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4164   void * jresult ;
4165   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4166   Dali::Vector4 *arg2 = 0 ;
4167   Dali::Vector2 *result = 0 ;
4168
4169   arg1 = (Dali::Vector2 *)jarg1;
4170   arg2 = (Dali::Vector4 *)jarg2;
4171   if (!arg2) {
4172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4173     return 0;
4174   }
4175   {
4176     try {
4177       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4178     } catch (std::out_of_range& e) {
4179       {
4180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4181       };
4182     } catch (std::exception& e) {
4183       {
4184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (...) {
4187       {
4188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4189       };
4190     }
4191   }
4192   jresult = (void *)result;
4193   return jresult;
4194 }
4195
4196
4197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4198   void * jresult ;
4199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4200   Dali::Vector2 *arg2 = 0 ;
4201   Dali::Vector2 result;
4202
4203   arg1 = (Dali::Vector2 *)jarg1;
4204   arg2 = (Dali::Vector2 *)jarg2;
4205   if (!arg2) {
4206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4207     return 0;
4208   }
4209   {
4210     try {
4211       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4212     } catch (std::out_of_range& e) {
4213       {
4214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4215       };
4216     } catch (std::exception& e) {
4217       {
4218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4219       };
4220     } catch (...) {
4221       {
4222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4223       };
4224     }
4225   }
4226   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4232   void * jresult ;
4233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4234   Dali::Vector2 *arg2 = 0 ;
4235   Dali::Vector2 *result = 0 ;
4236
4237   arg1 = (Dali::Vector2 *)jarg1;
4238   arg2 = (Dali::Vector2 *)jarg2;
4239   if (!arg2) {
4240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4241     return 0;
4242   }
4243   {
4244     try {
4245       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4246     } catch (std::out_of_range& e) {
4247       {
4248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (std::exception& e) {
4251       {
4252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (...) {
4255       {
4256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4257       };
4258     }
4259   }
4260   jresult = (void *)result;
4261   return jresult;
4262 }
4263
4264
4265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4266   void * jresult ;
4267   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4268   Dali::Vector2 *arg2 = 0 ;
4269   Dali::Vector2 result;
4270
4271   arg1 = (Dali::Vector2 *)jarg1;
4272   arg2 = (Dali::Vector2 *)jarg2;
4273   if (!arg2) {
4274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4275     return 0;
4276   }
4277   {
4278     try {
4279       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4280     } catch (std::out_of_range& e) {
4281       {
4282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4283       };
4284     } catch (std::exception& e) {
4285       {
4286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4287       };
4288     } catch (...) {
4289       {
4290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4291       };
4292     }
4293   }
4294   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4295   return jresult;
4296 }
4297
4298
4299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4300   void * jresult ;
4301   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4302   Dali::Vector2 *arg2 = 0 ;
4303   Dali::Vector2 *result = 0 ;
4304
4305   arg1 = (Dali::Vector2 *)jarg1;
4306   arg2 = (Dali::Vector2 *)jarg2;
4307   if (!arg2) {
4308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4309     return 0;
4310   }
4311   {
4312     try {
4313       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4314     } catch (std::out_of_range& e) {
4315       {
4316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (std::exception& e) {
4319       {
4320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4321       };
4322     } catch (...) {
4323       {
4324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4325       };
4326     }
4327   }
4328   jresult = (void *)result;
4329   return jresult;
4330 }
4331
4332
4333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4334   void * jresult ;
4335   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4336   Dali::Vector2 *arg2 = 0 ;
4337   Dali::Vector2 result;
4338
4339   arg1 = (Dali::Vector2 *)jarg1;
4340   arg2 = (Dali::Vector2 *)jarg2;
4341   if (!arg2) {
4342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4343     return 0;
4344   }
4345   {
4346     try {
4347       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4348     } catch (std::out_of_range& e) {
4349       {
4350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4351       };
4352     } catch (std::exception& e) {
4353       {
4354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4355       };
4356     } catch (...) {
4357       {
4358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4359       };
4360     }
4361   }
4362   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4368   void * jresult ;
4369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4370   float arg2 ;
4371   Dali::Vector2 result;
4372
4373   arg1 = (Dali::Vector2 *)jarg1;
4374   arg2 = (float)jarg2;
4375   {
4376     try {
4377       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4378     } catch (std::out_of_range& e) {
4379       {
4380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (std::exception& e) {
4383       {
4384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4385       };
4386     } catch (...) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4389       };
4390     }
4391   }
4392   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4398   void * jresult ;
4399   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4400   Dali::Vector2 *arg2 = 0 ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   arg1 = (Dali::Vector2 *)jarg1;
4404   arg2 = (Dali::Vector2 *)jarg2;
4405   if (!arg2) {
4406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4407     return 0;
4408   }
4409   {
4410     try {
4411       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4412     } catch (std::out_of_range& e) {
4413       {
4414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4415       };
4416     } catch (std::exception& e) {
4417       {
4418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4419       };
4420     } catch (...) {
4421       {
4422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4423       };
4424     }
4425   }
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4432   void * jresult ;
4433   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4434   float arg2 ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   arg1 = (Dali::Vector2 *)jarg1;
4438   arg2 = (float)jarg2;
4439   {
4440     try {
4441       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4442     } catch (std::out_of_range& e) {
4443       {
4444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4445       };
4446     } catch (std::exception& e) {
4447       {
4448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4449       };
4450     } catch (...) {
4451       {
4452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4453       };
4454     }
4455   }
4456   jresult = (void *)result;
4457   return jresult;
4458 }
4459
4460
4461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4462   void * jresult ;
4463   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4464   Dali::Vector2 *arg2 = 0 ;
4465   Dali::Vector2 result;
4466
4467   arg1 = (Dali::Vector2 *)jarg1;
4468   arg2 = (Dali::Vector2 *)jarg2;
4469   if (!arg2) {
4470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4471     return 0;
4472   }
4473   {
4474     try {
4475       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4476     } catch (std::out_of_range& e) {
4477       {
4478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4479       };
4480     } catch (std::exception& e) {
4481       {
4482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4483       };
4484     } catch (...) {
4485       {
4486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4487       };
4488     }
4489   }
4490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4491   return jresult;
4492 }
4493
4494
4495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4496   void * jresult ;
4497   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4498   float arg2 ;
4499   Dali::Vector2 result;
4500
4501   arg1 = (Dali::Vector2 *)jarg1;
4502   arg2 = (float)jarg2;
4503   {
4504     try {
4505       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4506     } catch (std::out_of_range& e) {
4507       {
4508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (std::exception& e) {
4511       {
4512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4513       };
4514     } catch (...) {
4515       {
4516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4517       };
4518     }
4519   }
4520   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4526   void * jresult ;
4527   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4528   Dali::Vector2 *arg2 = 0 ;
4529   Dali::Vector2 *result = 0 ;
4530
4531   arg1 = (Dali::Vector2 *)jarg1;
4532   arg2 = (Dali::Vector2 *)jarg2;
4533   if (!arg2) {
4534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4535     return 0;
4536   }
4537   {
4538     try {
4539       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4540     } catch (std::out_of_range& e) {
4541       {
4542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4543       };
4544     } catch (std::exception& e) {
4545       {
4546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (...) {
4549       {
4550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4551       };
4552     }
4553   }
4554   jresult = (void *)result;
4555   return jresult;
4556 }
4557
4558
4559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4560   void * jresult ;
4561   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4562   float arg2 ;
4563   Dali::Vector2 *result = 0 ;
4564
4565   arg1 = (Dali::Vector2 *)jarg1;
4566   arg2 = (float)jarg2;
4567   {
4568     try {
4569       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4570     } catch (std::out_of_range& e) {
4571       {
4572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4573       };
4574     } catch (std::exception& e) {
4575       {
4576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4577       };
4578     } catch (...) {
4579       {
4580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4581       };
4582     }
4583   }
4584   jresult = (void *)result;
4585   return jresult;
4586 }
4587
4588
4589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4590   void * jresult ;
4591   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4592   Dali::Vector2 result;
4593
4594   arg1 = (Dali::Vector2 *)jarg1;
4595   {
4596     try {
4597       result = ((Dali::Vector2 const *)arg1)->operator -();
4598     } catch (std::out_of_range& e) {
4599       {
4600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (std::exception& e) {
4603       {
4604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4605       };
4606     } catch (...) {
4607       {
4608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4609       };
4610     }
4611   }
4612   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4613   return jresult;
4614 }
4615
4616
4617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4618   unsigned int jresult ;
4619   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4620   Dali::Vector2 *arg2 = 0 ;
4621   bool result;
4622
4623   arg1 = (Dali::Vector2 *)jarg1;
4624   arg2 = (Dali::Vector2 *)jarg2;
4625   if (!arg2) {
4626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4627     return 0;
4628   }
4629   {
4630     try {
4631       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4632     } catch (std::out_of_range& e) {
4633       {
4634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (std::exception& e) {
4637       {
4638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646   jresult = result;
4647   return jresult;
4648 }
4649
4650
4651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4652   unsigned int jresult ;
4653   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4654   Dali::Vector2 *arg2 = 0 ;
4655   bool result;
4656
4657   arg1 = (Dali::Vector2 *)jarg1;
4658   arg2 = (Dali::Vector2 *)jarg2;
4659   if (!arg2) {
4660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4661     return 0;
4662   }
4663   {
4664     try {
4665       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4666     } catch (std::out_of_range& e) {
4667       {
4668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4669       };
4670     } catch (std::exception& e) {
4671       {
4672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (...) {
4675       {
4676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4677       };
4678     }
4679   }
4680   jresult = result;
4681   return jresult;
4682 }
4683
4684
4685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4686   float jresult ;
4687   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4688   unsigned int arg2 ;
4689   float *result = 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   arg2 = (unsigned int)jarg2;
4693   {
4694     try {
4695       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (...) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4707       };
4708     }
4709   }
4710   jresult = *result;
4711   return jresult;
4712 }
4713
4714
4715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4716   float jresult ;
4717   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4718   float result;
4719
4720   arg1 = (Dali::Vector2 *)jarg1;
4721   {
4722     try {
4723       result = (float)((Dali::Vector2 const *)arg1)->Length();
4724     } catch (std::out_of_range& e) {
4725       {
4726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4727       };
4728     } catch (std::exception& e) {
4729       {
4730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4731       };
4732     } catch (...) {
4733       {
4734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4735       };
4736     }
4737   }
4738   jresult = result;
4739   return jresult;
4740 }
4741
4742
4743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4744   float jresult ;
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float result;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   {
4750     try {
4751       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4752     } catch (std::out_of_range& e) {
4753       {
4754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4755       };
4756     } catch (std::exception& e) {
4757       {
4758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4759       };
4760     } catch (...) {
4761       {
4762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4763       };
4764     }
4765   }
4766   jresult = result;
4767   return jresult;
4768 }
4769
4770
4771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4772   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4773
4774   arg1 = (Dali::Vector2 *)jarg1;
4775   {
4776     try {
4777       (arg1)->Normalize();
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4785       };
4786     } catch (...) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4789       };
4790     }
4791   }
4792 }
4793
4794
4795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4797   Dali::Vector2 *arg2 = 0 ;
4798   Dali::Vector2 *arg3 = 0 ;
4799
4800   arg1 = (Dali::Vector2 *)jarg1;
4801   arg2 = (Dali::Vector2 *)jarg2;
4802   if (!arg2) {
4803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4804     return ;
4805   }
4806   arg3 = (Dali::Vector2 *)jarg3;
4807   if (!arg3) {
4808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4809     return ;
4810   }
4811   {
4812     try {
4813       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4814     } catch (std::out_of_range& e) {
4815       {
4816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4817       };
4818     } catch (std::exception& e) {
4819       {
4820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4821       };
4822     } catch (...) {
4823       {
4824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4825       };
4826     }
4827   }
4828 }
4829
4830
4831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4832   void * jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   float *result = 0 ;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   {
4838     try {
4839       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4840     } catch (std::out_of_range& e) {
4841       {
4842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4843       };
4844     } catch (std::exception& e) {
4845       {
4846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4847       };
4848     } catch (...) {
4849       {
4850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4851       };
4852     }
4853   }
4854   jresult = (void *)result;
4855   return jresult;
4856 }
4857
4858
4859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4860   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4861   float arg2 ;
4862
4863   arg1 = (Dali::Vector2 *)jarg1;
4864   arg2 = (float)jarg2;
4865   if (arg1) (arg1)->x = arg2;
4866 }
4867
4868
4869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4870   float jresult ;
4871   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4872   float result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   result = (float) ((arg1)->x);
4876   jresult = result;
4877   return jresult;
4878 }
4879
4880
4881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4882   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4883   float arg2 ;
4884
4885   arg1 = (Dali::Vector2 *)jarg1;
4886   arg2 = (float)jarg2;
4887   if (arg1) (arg1)->width = arg2;
4888 }
4889
4890
4891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4892   float jresult ;
4893   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4894   float result;
4895
4896   arg1 = (Dali::Vector2 *)jarg1;
4897   result = (float) ((arg1)->width);
4898   jresult = result;
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4904   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4905   float arg2 ;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (float)jarg2;
4909   if (arg1) (arg1)->y = arg2;
4910 }
4911
4912
4913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4914   float jresult ;
4915   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4916   float result;
4917
4918   arg1 = (Dali::Vector2 *)jarg1;
4919   result = (float) ((arg1)->y);
4920   jresult = result;
4921   return jresult;
4922 }
4923
4924
4925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4926   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4927   float arg2 ;
4928
4929   arg1 = (Dali::Vector2 *)jarg1;
4930   arg2 = (float)jarg2;
4931   if (arg1) (arg1)->height = arg2;
4932 }
4933
4934
4935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4936   float jresult ;
4937   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4938   float result;
4939
4940   arg1 = (Dali::Vector2 *)jarg1;
4941   result = (float) ((arg1)->height);
4942   jresult = result;
4943   return jresult;
4944 }
4945
4946
4947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4948   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   {
4952     try {
4953       delete arg1;
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4961       };
4962     } catch (...) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4965       };
4966     }
4967   }
4968 }
4969
4970
4971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4972   void * jresult ;
4973   Dali::Vector2 *arg1 = 0 ;
4974   Dali::Vector2 *arg2 = 0 ;
4975   Dali::Vector2 result;
4976
4977   arg1 = (Dali::Vector2 *)jarg1;
4978   if (!arg1) {
4979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4980     return 0;
4981   }
4982   arg2 = (Dali::Vector2 *)jarg2;
4983   if (!arg2) {
4984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4985     return 0;
4986   }
4987   {
4988     try {
4989       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4990     } catch (std::out_of_range& e) {
4991       {
4992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (std::exception& e) {
4995       {
4996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5010   void * jresult ;
5011   Dali::Vector2 *arg1 = 0 ;
5012   Dali::Vector2 *arg2 = 0 ;
5013   Dali::Vector2 result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   if (!arg1) {
5017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5018     return 0;
5019   }
5020   arg2 = (Dali::Vector2 *)jarg2;
5021   if (!arg2) {
5022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5023     return 0;
5024   }
5025   {
5026     try {
5027       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5028     } catch (std::out_of_range& e) {
5029       {
5030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5031       };
5032     } catch (std::exception& e) {
5033       {
5034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (...) {
5037       {
5038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5039       };
5040     }
5041   }
5042   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5043   return jresult;
5044 }
5045
5046
5047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5048   void * jresult ;
5049   Dali::Vector2 *arg1 = 0 ;
5050   float *arg2 = 0 ;
5051   float *arg3 = 0 ;
5052   float temp2 ;
5053   float temp3 ;
5054   Dali::Vector2 result;
5055
5056   arg1 = (Dali::Vector2 *)jarg1;
5057   if (!arg1) {
5058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5059     return 0;
5060   }
5061   temp2 = (float)jarg2;
5062   arg2 = &temp2;
5063   temp3 = (float)jarg3;
5064   arg3 = &temp3;
5065   {
5066     try {
5067       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5068     } catch (std::out_of_range& e) {
5069       {
5070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (std::exception& e) {
5073       {
5074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (...) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5079       };
5080     }
5081   }
5082   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5083   return jresult;
5084 }
5085
5086
5087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5088   void * jresult ;
5089   Dali::Vector3 *result = 0 ;
5090
5091   {
5092     try {
5093       result = (Dali::Vector3 *)new Dali::Vector3();
5094     } catch (std::out_of_range& e) {
5095       {
5096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5097       };
5098     } catch (std::exception& e) {
5099       {
5100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5101       };
5102     } catch (...) {
5103       {
5104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5105       };
5106     }
5107   }
5108   jresult = (void *)result;
5109   return jresult;
5110 }
5111
5112
5113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5114   void * jresult ;
5115   float arg1 ;
5116   float arg2 ;
5117   float arg3 ;
5118   Dali::Vector3 *result = 0 ;
5119
5120   arg1 = (float)jarg1;
5121   arg2 = (float)jarg2;
5122   arg3 = (float)jarg3;
5123   {
5124     try {
5125       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5126     } catch (std::out_of_range& e) {
5127       {
5128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5129       };
5130     } catch (std::exception& e) {
5131       {
5132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5133       };
5134     } catch (...) {
5135       {
5136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5137       };
5138     }
5139   }
5140   jresult = (void *)result;
5141   return jresult;
5142 }
5143
5144
5145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5146   void * jresult ;
5147   float *arg1 = (float *) 0 ;
5148   Dali::Vector3 *result = 0 ;
5149
5150   arg1 = jarg1;
5151   {
5152     try {
5153       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5154     } catch (std::out_of_range& e) {
5155       {
5156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5157       };
5158     } catch (std::exception& e) {
5159       {
5160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5161       };
5162     } catch (...) {
5163       {
5164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5165       };
5166     }
5167   }
5168   jresult = (void *)result;
5169
5170
5171   return jresult;
5172 }
5173
5174
5175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5176   void * jresult ;
5177   Dali::Vector2 *arg1 = 0 ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   arg1 = (Dali::Vector2 *)jarg1;
5181   if (!arg1) {
5182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5183     return 0;
5184   }
5185   {
5186     try {
5187       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5188     } catch (std::out_of_range& e) {
5189       {
5190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5191       };
5192     } catch (std::exception& e) {
5193       {
5194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5195       };
5196     } catch (...) {
5197       {
5198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5199       };
5200     }
5201   }
5202   jresult = (void *)result;
5203   return jresult;
5204 }
5205
5206
5207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5208   void * jresult ;
5209   Dali::Vector4 *arg1 = 0 ;
5210   Dali::Vector3 *result = 0 ;
5211
5212   arg1 = (Dali::Vector4 *)jarg1;
5213   if (!arg1) {
5214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5215     return 0;
5216   }
5217   {
5218     try {
5219       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5220     } catch (std::out_of_range& e) {
5221       {
5222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5223       };
5224     } catch (std::exception& e) {
5225       {
5226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5227       };
5228     } catch (...) {
5229       {
5230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5231       };
5232     }
5233   }
5234   jresult = (void *)result;
5235   return jresult;
5236 }
5237
5238
5239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5240   void * jresult ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5244   jresult = (void *)result;
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5250   void * jresult ;
5251   Dali::Vector3 *result = 0 ;
5252
5253   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5254   jresult = (void *)result;
5255   return jresult;
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5260   void * jresult ;
5261   Dali::Vector3 *result = 0 ;
5262
5263   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5264   jresult = (void *)result;
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5270   void * jresult ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5274   jresult = (void *)result;
5275   return jresult;
5276 }
5277
5278
5279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5280   void * jresult ;
5281   Dali::Vector3 *result = 0 ;
5282
5283   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5284   jresult = (void *)result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5290   void * jresult ;
5291   Dali::Vector3 *result = 0 ;
5292
5293   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5294   jresult = (void *)result;
5295   return jresult;
5296 }
5297
5298
5299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5300   void * jresult ;
5301   Dali::Vector3 *result = 0 ;
5302
5303   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5304   jresult = (void *)result;
5305   return jresult;
5306 }
5307
5308
5309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5310   void * jresult ;
5311   Dali::Vector3 *result = 0 ;
5312
5313   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5314   jresult = (void *)result;
5315   return jresult;
5316 }
5317
5318
5319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5320   void * jresult ;
5321   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5322   float *arg2 = (float *) 0 ;
5323   Dali::Vector3 *result = 0 ;
5324
5325   arg1 = (Dali::Vector3 *)jarg1;
5326   arg2 = jarg2;
5327   {
5328     try {
5329       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5330     } catch (std::out_of_range& e) {
5331       {
5332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5333       };
5334     } catch (std::exception& e) {
5335       {
5336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5337       };
5338     } catch (...) {
5339       {
5340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5341       };
5342     }
5343   }
5344   jresult = (void *)result;
5345
5346
5347   return jresult;
5348 }
5349
5350
5351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5352   void * jresult ;
5353   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5354   Dali::Vector2 *arg2 = 0 ;
5355   Dali::Vector3 *result = 0 ;
5356
5357   arg1 = (Dali::Vector3 *)jarg1;
5358   arg2 = (Dali::Vector2 *)jarg2;
5359   if (!arg2) {
5360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5361     return 0;
5362   }
5363   {
5364     try {
5365       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5366     } catch (std::out_of_range& e) {
5367       {
5368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5369       };
5370     } catch (std::exception& e) {
5371       {
5372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5373       };
5374     } catch (...) {
5375       {
5376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5377       };
5378     }
5379   }
5380   jresult = (void *)result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5386   void * jresult ;
5387   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5388   Dali::Vector4 *arg2 = 0 ;
5389   Dali::Vector3 *result = 0 ;
5390
5391   arg1 = (Dali::Vector3 *)jarg1;
5392   arg2 = (Dali::Vector4 *)jarg2;
5393   if (!arg2) {
5394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5395     return 0;
5396   }
5397   {
5398     try {
5399       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5400     } catch (std::out_of_range& e) {
5401       {
5402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5403       };
5404     } catch (std::exception& e) {
5405       {
5406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5407       };
5408     } catch (...) {
5409       {
5410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5411       };
5412     }
5413   }
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5420   void * jresult ;
5421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5422   Dali::Vector3 *arg2 = 0 ;
5423   Dali::Vector3 result;
5424
5425   arg1 = (Dali::Vector3 *)jarg1;
5426   arg2 = (Dali::Vector3 *)jarg2;
5427   if (!arg2) {
5428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5429     return 0;
5430   }
5431   {
5432     try {
5433       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5456   Dali::Vector3 *arg2 = 0 ;
5457   Dali::Vector3 *result = 0 ;
5458
5459   arg1 = (Dali::Vector3 *)jarg1;
5460   arg2 = (Dali::Vector3 *)jarg2;
5461   if (!arg2) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5463     return 0;
5464   }
5465   {
5466     try {
5467       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5468     } catch (std::out_of_range& e) {
5469       {
5470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (std::exception& e) {
5473       {
5474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482   jresult = (void *)result;
5483   return jresult;
5484 }
5485
5486
5487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5488   void * jresult ;
5489   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5490   Dali::Vector3 *arg2 = 0 ;
5491   Dali::Vector3 result;
5492
5493   arg1 = (Dali::Vector3 *)jarg1;
5494   arg2 = (Dali::Vector3 *)jarg2;
5495   if (!arg2) {
5496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5497     return 0;
5498   }
5499   {
5500     try {
5501       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5502     } catch (std::out_of_range& e) {
5503       {
5504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5505       };
5506     } catch (std::exception& e) {
5507       {
5508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5509       };
5510     } catch (...) {
5511       {
5512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5513       };
5514     }
5515   }
5516   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5517   return jresult;
5518 }
5519
5520
5521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5522   void * jresult ;
5523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5524   Dali::Vector3 *arg2 = 0 ;
5525   Dali::Vector3 *result = 0 ;
5526
5527   arg1 = (Dali::Vector3 *)jarg1;
5528   arg2 = (Dali::Vector3 *)jarg2;
5529   if (!arg2) {
5530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5531     return 0;
5532   }
5533   {
5534     try {
5535       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5536     } catch (std::out_of_range& e) {
5537       {
5538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (std::exception& e) {
5541       {
5542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5543       };
5544     } catch (...) {
5545       {
5546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5547       };
5548     }
5549   }
5550   jresult = (void *)result;
5551   return jresult;
5552 }
5553
5554
5555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5556   void * jresult ;
5557   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5558   Dali::Vector3 *arg2 = 0 ;
5559   Dali::Vector3 result;
5560
5561   arg1 = (Dali::Vector3 *)jarg1;
5562   arg2 = (Dali::Vector3 *)jarg2;
5563   if (!arg2) {
5564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5565     return 0;
5566   }
5567   {
5568     try {
5569       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (...) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5581       };
5582     }
5583   }
5584   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5590   void * jresult ;
5591   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5592   float arg2 ;
5593   Dali::Vector3 result;
5594
5595   arg1 = (Dali::Vector3 *)jarg1;
5596   arg2 = (float)jarg2;
5597   {
5598     try {
5599       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5600     } catch (std::out_of_range& e) {
5601       {
5602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (std::exception& e) {
5605       {
5606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5615   return jresult;
5616 }
5617
5618
5619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5620   void * jresult ;
5621   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5622   Dali::Vector3 *arg2 = 0 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (Dali::Vector3 *)jarg1;
5626   arg2 = (Dali::Vector3 *)jarg2;
5627   if (!arg2) {
5628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5629     return 0;
5630   }
5631   {
5632     try {
5633       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5634     } catch (std::out_of_range& e) {
5635       {
5636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (std::exception& e) {
5639       {
5640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5654   void * jresult ;
5655   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5656   float arg2 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = (Dali::Vector3 *)jarg1;
5660   arg2 = (float)jarg2;
5661   {
5662     try {
5663       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (...) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5675       };
5676     }
5677   }
5678   jresult = (void *)result;
5679   return jresult;
5680 }
5681
5682
5683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5684   void * jresult ;
5685   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5686   Dali::Quaternion *arg2 = 0 ;
5687   Dali::Vector3 *result = 0 ;
5688
5689   arg1 = (Dali::Vector3 *)jarg1;
5690   arg2 = (Dali::Quaternion *)jarg2;
5691   if (!arg2) {
5692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5693     return 0;
5694   }
5695   {
5696     try {
5697       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5698     } catch (std::out_of_range& e) {
5699       {
5700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (std::exception& e) {
5703       {
5704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (...) {
5707       {
5708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5709       };
5710     }
5711   }
5712   jresult = (void *)result;
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5718   void * jresult ;
5719   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5720   Dali::Vector3 *arg2 = 0 ;
5721   Dali::Vector3 result;
5722
5723   arg1 = (Dali::Vector3 *)jarg1;
5724   arg2 = (Dali::Vector3 *)jarg2;
5725   if (!arg2) {
5726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5727     return 0;
5728   }
5729   {
5730     try {
5731       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5732     } catch (std::out_of_range& e) {
5733       {
5734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5735       };
5736     } catch (std::exception& e) {
5737       {
5738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5739       };
5740     } catch (...) {
5741       {
5742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5743       };
5744     }
5745   }
5746   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5747   return jresult;
5748 }
5749
5750
5751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5752   void * jresult ;
5753   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5754   float arg2 ;
5755   Dali::Vector3 result;
5756
5757   arg1 = (Dali::Vector3 *)jarg1;
5758   arg2 = (float)jarg2;
5759   {
5760     try {
5761       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5762     } catch (std::out_of_range& e) {
5763       {
5764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5765       };
5766     } catch (std::exception& e) {
5767       {
5768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5769       };
5770     } catch (...) {
5771       {
5772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5773       };
5774     }
5775   }
5776   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5782   void * jresult ;
5783   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5784   Dali::Vector3 *arg2 = 0 ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   arg1 = (Dali::Vector3 *)jarg1;
5788   arg2 = (Dali::Vector3 *)jarg2;
5789   if (!arg2) {
5790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5791     return 0;
5792   }
5793   {
5794     try {
5795       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5796     } catch (std::out_of_range& e) {
5797       {
5798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5799       };
5800     } catch (std::exception& e) {
5801       {
5802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5803       };
5804     } catch (...) {
5805       {
5806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5807       };
5808     }
5809   }
5810   jresult = (void *)result;
5811   return jresult;
5812 }
5813
5814
5815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5816   void * jresult ;
5817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5818   float arg2 ;
5819   Dali::Vector3 *result = 0 ;
5820
5821   arg1 = (Dali::Vector3 *)jarg1;
5822   arg2 = (float)jarg2;
5823   {
5824     try {
5825       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5826     } catch (std::out_of_range& e) {
5827       {
5828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5829       };
5830     } catch (std::exception& e) {
5831       {
5832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5833       };
5834     } catch (...) {
5835       {
5836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5837       };
5838     }
5839   }
5840   jresult = (void *)result;
5841   return jresult;
5842 }
5843
5844
5845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5846   void * jresult ;
5847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5848   Dali::Vector3 result;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   {
5852     try {
5853       result = ((Dali::Vector3 const *)arg1)->operator -();
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (...) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5865       };
5866     }
5867   }
5868   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5869   return jresult;
5870 }
5871
5872
5873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5874   unsigned int jresult ;
5875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5876   Dali::Vector3 *arg2 = 0 ;
5877   bool result;
5878
5879   arg1 = (Dali::Vector3 *)jarg1;
5880   arg2 = (Dali::Vector3 *)jarg2;
5881   if (!arg2) {
5882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5883     return 0;
5884   }
5885   {
5886     try {
5887       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5888     } catch (std::out_of_range& e) {
5889       {
5890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (std::exception& e) {
5893       {
5894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (...) {
5897       {
5898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5899       };
5900     }
5901   }
5902   jresult = result;
5903   return jresult;
5904 }
5905
5906
5907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5908   unsigned int jresult ;
5909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5910   Dali::Vector3 *arg2 = 0 ;
5911   bool result;
5912
5913   arg1 = (Dali::Vector3 *)jarg1;
5914   arg2 = (Dali::Vector3 *)jarg2;
5915   if (!arg2) {
5916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5917     return 0;
5918   }
5919   {
5920     try {
5921       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5922     } catch (std::out_of_range& e) {
5923       {
5924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5925       };
5926     } catch (std::exception& e) {
5927       {
5928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5929       };
5930     } catch (...) {
5931       {
5932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5933       };
5934     }
5935   }
5936   jresult = result;
5937   return jresult;
5938 }
5939
5940
5941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5942   float jresult ;
5943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5944   unsigned int arg2 ;
5945   float *result = 0 ;
5946
5947   arg1 = (Dali::Vector3 *)jarg1;
5948   arg2 = (unsigned int)jarg2;
5949   {
5950     try {
5951       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5952     } catch (std::out_of_range& e) {
5953       {
5954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (std::exception& e) {
5957       {
5958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5959       };
5960     } catch (...) {
5961       {
5962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5963       };
5964     }
5965   }
5966   jresult = *result;
5967   return jresult;
5968 }
5969
5970
5971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5972   float jresult ;
5973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5974   Dali::Vector3 *arg2 = 0 ;
5975   float result;
5976
5977   arg1 = (Dali::Vector3 *)jarg1;
5978   arg2 = (Dali::Vector3 *)jarg2;
5979   if (!arg2) {
5980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5981     return 0;
5982   }
5983   {
5984     try {
5985       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5986     } catch (std::out_of_range& e) {
5987       {
5988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (std::exception& e) {
5991       {
5992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5993       };
5994     } catch (...) {
5995       {
5996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5997       };
5998     }
5999   }
6000   jresult = result;
6001   return jresult;
6002 }
6003
6004
6005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6006   void * jresult ;
6007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6008   Dali::Vector3 *arg2 = 0 ;
6009   Dali::Vector3 result;
6010
6011   arg1 = (Dali::Vector3 *)jarg1;
6012   arg2 = (Dali::Vector3 *)jarg2;
6013   if (!arg2) {
6014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6015     return 0;
6016   }
6017   {
6018     try {
6019       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (...) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6031       };
6032     }
6033   }
6034   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6040   float jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   float result;
6043
6044   arg1 = (Dali::Vector3 *)jarg1;
6045   {
6046     try {
6047       result = (float)((Dali::Vector3 const *)arg1)->Length();
6048     } catch (std::out_of_range& e) {
6049       {
6050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (std::exception& e) {
6053       {
6054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (...) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6059       };
6060     }
6061   }
6062   jresult = result;
6063   return jresult;
6064 }
6065
6066
6067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6068   float jresult ;
6069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6070   float result;
6071
6072   arg1 = (Dali::Vector3 *)jarg1;
6073   {
6074     try {
6075       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6076     } catch (std::out_of_range& e) {
6077       {
6078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6079       };
6080     } catch (std::exception& e) {
6081       {
6082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (...) {
6085       {
6086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6087       };
6088     }
6089   }
6090   jresult = result;
6091   return jresult;
6092 }
6093
6094
6095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6097
6098   arg1 = (Dali::Vector3 *)jarg1;
6099   {
6100     try {
6101       (arg1)->Normalize();
6102     } catch (std::out_of_range& e) {
6103       {
6104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6105       };
6106     } catch (std::exception& e) {
6107       {
6108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6113       };
6114     }
6115   }
6116 }
6117
6118
6119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6120   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6121   Dali::Vector3 *arg2 = 0 ;
6122   Dali::Vector3 *arg3 = 0 ;
6123
6124   arg1 = (Dali::Vector3 *)jarg1;
6125   arg2 = (Dali::Vector3 *)jarg2;
6126   if (!arg2) {
6127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6128     return ;
6129   }
6130   arg3 = (Dali::Vector3 *)jarg3;
6131   if (!arg3) {
6132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6133     return ;
6134   }
6135   {
6136     try {
6137       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6149       };
6150     }
6151   }
6152 }
6153
6154
6155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6156   void * jresult ;
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float *result = 0 ;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   {
6162     try {
6163       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (...) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6175       };
6176     }
6177   }
6178   jresult = (void *)result;
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   Dali::Vector2 *result = 0 ;
6187
6188   arg1 = (Dali::Vector3 *)jarg1;
6189   {
6190     try {
6191       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6192     } catch (std::out_of_range& e) {
6193       {
6194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6195       };
6196     } catch (std::exception& e) {
6197       {
6198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (...) {
6201       {
6202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6203       };
6204     }
6205   }
6206   jresult = (void *)result;
6207   return jresult;
6208 }
6209
6210
6211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6212   void * jresult ;
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   Dali::Vector2 *result = 0 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   {
6218     try {
6219       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6220     } catch (std::out_of_range& e) {
6221       {
6222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6223       };
6224     } catch (std::exception& e) {
6225       {
6226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6227       };
6228     } catch (...) {
6229       {
6230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6231       };
6232     }
6233   }
6234   jresult = (void *)result;
6235   return jresult;
6236 }
6237
6238
6239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6240   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6241   float arg2 ;
6242
6243   arg1 = (Dali::Vector3 *)jarg1;
6244   arg2 = (float)jarg2;
6245   if (arg1) (arg1)->x = arg2;
6246 }
6247
6248
6249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6250   float jresult ;
6251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6252   float result;
6253
6254   arg1 = (Dali::Vector3 *)jarg1;
6255   result = (float) ((arg1)->x);
6256   jresult = result;
6257   return jresult;
6258 }
6259
6260
6261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6262   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6263   float arg2 ;
6264
6265   arg1 = (Dali::Vector3 *)jarg1;
6266   arg2 = (float)jarg2;
6267   if (arg1) (arg1)->width = arg2;
6268 }
6269
6270
6271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6272   float jresult ;
6273   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6274   float result;
6275
6276   arg1 = (Dali::Vector3 *)jarg1;
6277   result = (float) ((arg1)->width);
6278   jresult = result;
6279   return jresult;
6280 }
6281
6282
6283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6284   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6285   float arg2 ;
6286
6287   arg1 = (Dali::Vector3 *)jarg1;
6288   arg2 = (float)jarg2;
6289   if (arg1) (arg1)->r = arg2;
6290 }
6291
6292
6293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6294   float jresult ;
6295   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6296   float result;
6297
6298   arg1 = (Dali::Vector3 *)jarg1;
6299   result = (float) ((arg1)->r);
6300   jresult = result;
6301   return jresult;
6302 }
6303
6304
6305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   float arg2 ;
6308
6309   arg1 = (Dali::Vector3 *)jarg1;
6310   arg2 = (float)jarg2;
6311   if (arg1) (arg1)->y = arg2;
6312 }
6313
6314
6315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6316   float jresult ;
6317   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6318   float result;
6319
6320   arg1 = (Dali::Vector3 *)jarg1;
6321   result = (float) ((arg1)->y);
6322   jresult = result;
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6328   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6329   float arg2 ;
6330
6331   arg1 = (Dali::Vector3 *)jarg1;
6332   arg2 = (float)jarg2;
6333   if (arg1) (arg1)->height = arg2;
6334 }
6335
6336
6337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6338   float jresult ;
6339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6340   float result;
6341
6342   arg1 = (Dali::Vector3 *)jarg1;
6343   result = (float) ((arg1)->height);
6344   jresult = result;
6345   return jresult;
6346 }
6347
6348
6349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6351   float arg2 ;
6352
6353   arg1 = (Dali::Vector3 *)jarg1;
6354   arg2 = (float)jarg2;
6355   if (arg1) (arg1)->g = arg2;
6356 }
6357
6358
6359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6360   float jresult ;
6361   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6362   float result;
6363
6364   arg1 = (Dali::Vector3 *)jarg1;
6365   result = (float) ((arg1)->g);
6366   jresult = result;
6367   return jresult;
6368 }
6369
6370
6371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   float arg2 ;
6374
6375   arg1 = (Dali::Vector3 *)jarg1;
6376   arg2 = (float)jarg2;
6377   if (arg1) (arg1)->z = arg2;
6378 }
6379
6380
6381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6382   float jresult ;
6383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6384   float result;
6385
6386   arg1 = (Dali::Vector3 *)jarg1;
6387   result = (float) ((arg1)->z);
6388   jresult = result;
6389   return jresult;
6390 }
6391
6392
6393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6394   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6395   float arg2 ;
6396
6397   arg1 = (Dali::Vector3 *)jarg1;
6398   arg2 = (float)jarg2;
6399   if (arg1) (arg1)->depth = arg2;
6400 }
6401
6402
6403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6404   float jresult ;
6405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6406   float result;
6407
6408   arg1 = (Dali::Vector3 *)jarg1;
6409   result = (float) ((arg1)->depth);
6410   jresult = result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418
6419   arg1 = (Dali::Vector3 *)jarg1;
6420   arg2 = (float)jarg2;
6421   if (arg1) (arg1)->b = arg2;
6422 }
6423
6424
6425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6426   float jresult ;
6427   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6428   float result;
6429
6430   arg1 = (Dali::Vector3 *)jarg1;
6431   result = (float) ((arg1)->b);
6432   jresult = result;
6433   return jresult;
6434 }
6435
6436
6437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439
6440   arg1 = (Dali::Vector3 *)jarg1;
6441   {
6442     try {
6443       delete arg1;
6444     } catch (std::out_of_range& e) {
6445       {
6446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6447       };
6448     } catch (std::exception& e) {
6449       {
6450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6451       };
6452     } catch (...) {
6453       {
6454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6455       };
6456     }
6457   }
6458 }
6459
6460
6461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6462   void * jresult ;
6463   Dali::Vector3 *arg1 = 0 ;
6464   Dali::Vector3 *arg2 = 0 ;
6465   Dali::Vector3 result;
6466
6467   arg1 = (Dali::Vector3 *)jarg1;
6468   if (!arg1) {
6469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6470     return 0;
6471   }
6472   arg2 = (Dali::Vector3 *)jarg2;
6473   if (!arg2) {
6474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6475     return 0;
6476   }
6477   {
6478     try {
6479       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6480     } catch (std::out_of_range& e) {
6481       {
6482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (std::exception& e) {
6485       {
6486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (...) {
6489       {
6490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6491       };
6492     }
6493   }
6494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6495   return jresult;
6496 }
6497
6498
6499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6500   void * jresult ;
6501   Dali::Vector3 *arg1 = 0 ;
6502   Dali::Vector3 *arg2 = 0 ;
6503   Dali::Vector3 result;
6504
6505   arg1 = (Dali::Vector3 *)jarg1;
6506   if (!arg1) {
6507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6508     return 0;
6509   }
6510   arg2 = (Dali::Vector3 *)jarg2;
6511   if (!arg2) {
6512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6513     return 0;
6514   }
6515   {
6516     try {
6517       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
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 = new Dali::Vector3((const Dali::Vector3 &)result);
6533   return jresult;
6534 }
6535
6536
6537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6538   void * jresult ;
6539   Dali::Vector3 *arg1 = 0 ;
6540   float *arg2 = 0 ;
6541   float *arg3 = 0 ;
6542   float temp2 ;
6543   float temp3 ;
6544   Dali::Vector3 result;
6545
6546   arg1 = (Dali::Vector3 *)jarg1;
6547   if (!arg1) {
6548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6549     return 0;
6550   }
6551   temp2 = (float)jarg2;
6552   arg2 = &temp2;
6553   temp3 = (float)jarg3;
6554   arg3 = &temp3;
6555   {
6556     try {
6557       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6558     } catch (std::out_of_range& e) {
6559       {
6560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6561       };
6562     } catch (std::exception& e) {
6563       {
6564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (...) {
6567       {
6568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6569       };
6570     }
6571   }
6572   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6573   return jresult;
6574 }
6575
6576
6577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6578   void * jresult ;
6579   Dali::Vector4 *result = 0 ;
6580
6581   {
6582     try {
6583       result = (Dali::Vector4 *)new Dali::Vector4();
6584     } catch (std::out_of_range& e) {
6585       {
6586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (std::exception& e) {
6589       {
6590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6591       };
6592     } catch (...) {
6593       {
6594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6595       };
6596     }
6597   }
6598   jresult = (void *)result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6604   void * jresult ;
6605   float arg1 ;
6606   float arg2 ;
6607   float arg3 ;
6608   float arg4 ;
6609   Dali::Vector4 *result = 0 ;
6610
6611   arg1 = (float)jarg1;
6612   arg2 = (float)jarg2;
6613   arg3 = (float)jarg3;
6614   arg4 = (float)jarg4;
6615   {
6616     try {
6617       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6618     } catch (std::out_of_range& e) {
6619       {
6620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6621       };
6622     } catch (std::exception& e) {
6623       {
6624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (...) {
6627       {
6628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6629       };
6630     }
6631   }
6632   jresult = (void *)result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6638   void * jresult ;
6639   float *arg1 = (float *) 0 ;
6640   Dali::Vector4 *result = 0 ;
6641
6642   arg1 = jarg1;
6643   {
6644     try {
6645       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6646     } catch (std::out_of_range& e) {
6647       {
6648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (std::exception& e) {
6651       {
6652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (...) {
6655       {
6656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6657       };
6658     }
6659   }
6660   jresult = (void *)result;
6661
6662
6663   return jresult;
6664 }
6665
6666
6667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6668   void * jresult ;
6669   Dali::Vector2 *arg1 = 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector2 *)jarg1;
6673   if (!arg1) {
6674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6675     return 0;
6676   }
6677   {
6678     try {
6679       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6680     } catch (std::out_of_range& e) {
6681       {
6682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6683       };
6684     } catch (std::exception& e) {
6685       {
6686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6687       };
6688     } catch (...) {
6689       {
6690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6691       };
6692     }
6693   }
6694   jresult = (void *)result;
6695   return jresult;
6696 }
6697
6698
6699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6700   void * jresult ;
6701   Dali::Vector3 *arg1 = 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector3 *)jarg1;
6705   if (!arg1) {
6706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6707     return 0;
6708   }
6709   {
6710     try {
6711       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6712     } catch (std::out_of_range& e) {
6713       {
6714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6715       };
6716     } catch (std::exception& e) {
6717       {
6718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (...) {
6721       {
6722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6723       };
6724     }
6725   }
6726   jresult = (void *)result;
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6732   void * jresult ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6742   void * jresult ;
6743   Dali::Vector4 *result = 0 ;
6744
6745   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6752   void * jresult ;
6753   Dali::Vector4 *result = 0 ;
6754
6755   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6762   void * jresult ;
6763   Dali::Vector4 *result = 0 ;
6764
6765   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6766   jresult = (void *)result;
6767   return jresult;
6768 }
6769
6770
6771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6772   void * jresult ;
6773   Dali::Vector4 *result = 0 ;
6774
6775   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6776   jresult = (void *)result;
6777   return jresult;
6778 }
6779
6780
6781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6782   void * jresult ;
6783   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6784   float *arg2 = (float *) 0 ;
6785   Dali::Vector4 *result = 0 ;
6786
6787   arg1 = (Dali::Vector4 *)jarg1;
6788   arg2 = jarg2;
6789   {
6790     try {
6791       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6792     } catch (std::out_of_range& e) {
6793       {
6794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6795       };
6796     } catch (std::exception& e) {
6797       {
6798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6803       };
6804     }
6805   }
6806   jresult = (void *)result;
6807
6808
6809   return jresult;
6810 }
6811
6812
6813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6814   void * jresult ;
6815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6816   Dali::Vector2 *arg2 = 0 ;
6817   Dali::Vector4 *result = 0 ;
6818
6819   arg1 = (Dali::Vector4 *)jarg1;
6820   arg2 = (Dali::Vector2 *)jarg2;
6821   if (!arg2) {
6822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6823     return 0;
6824   }
6825   {
6826     try {
6827       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6828     } catch (std::out_of_range& e) {
6829       {
6830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (std::exception& e) {
6833       {
6834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6835       };
6836     } catch (...) {
6837       {
6838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6839       };
6840     }
6841   }
6842   jresult = (void *)result;
6843   return jresult;
6844 }
6845
6846
6847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6848   void * jresult ;
6849   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6850   Dali::Vector3 *arg2 = 0 ;
6851   Dali::Vector4 *result = 0 ;
6852
6853   arg1 = (Dali::Vector4 *)jarg1;
6854   arg2 = (Dali::Vector3 *)jarg2;
6855   if (!arg2) {
6856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6857     return 0;
6858   }
6859   {
6860     try {
6861       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6862     } catch (std::out_of_range& e) {
6863       {
6864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6865       };
6866     } catch (std::exception& e) {
6867       {
6868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6869       };
6870     } catch (...) {
6871       {
6872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6873       };
6874     }
6875   }
6876   jresult = (void *)result;
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6882   void * jresult ;
6883   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6884   Dali::Vector4 *arg2 = 0 ;
6885   Dali::Vector4 result;
6886
6887   arg1 = (Dali::Vector4 *)jarg1;
6888   arg2 = (Dali::Vector4 *)jarg2;
6889   if (!arg2) {
6890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6891     return 0;
6892   }
6893   {
6894     try {
6895       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6896     } catch (std::out_of_range& e) {
6897       {
6898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (std::exception& e) {
6901       {
6902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6911   return jresult;
6912 }
6913
6914
6915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6916   void * jresult ;
6917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6918   Dali::Vector4 *arg2 = 0 ;
6919   Dali::Vector4 *result = 0 ;
6920
6921   arg1 = (Dali::Vector4 *)jarg1;
6922   arg2 = (Dali::Vector4 *)jarg2;
6923   if (!arg2) {
6924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6925     return 0;
6926   }
6927   {
6928     try {
6929       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6930     } catch (std::out_of_range& e) {
6931       {
6932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6933       };
6934     } catch (std::exception& e) {
6935       {
6936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6937       };
6938     } catch (...) {
6939       {
6940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6941       };
6942     }
6943   }
6944   jresult = (void *)result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6950   void * jresult ;
6951   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6952   Dali::Vector4 *arg2 = 0 ;
6953   Dali::Vector4 result;
6954
6955   arg1 = (Dali::Vector4 *)jarg1;
6956   arg2 = (Dali::Vector4 *)jarg2;
6957   if (!arg2) {
6958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6959     return 0;
6960   }
6961   {
6962     try {
6963       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6964     } catch (std::out_of_range& e) {
6965       {
6966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6967       };
6968     } catch (std::exception& e) {
6969       {
6970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6971       };
6972     } catch (...) {
6973       {
6974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6975       };
6976     }
6977   }
6978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6979   return jresult;
6980 }
6981
6982
6983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6984   void * jresult ;
6985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6986   Dali::Vector4 *arg2 = 0 ;
6987   Dali::Vector4 *result = 0 ;
6988
6989   arg1 = (Dali::Vector4 *)jarg1;
6990   arg2 = (Dali::Vector4 *)jarg2;
6991   if (!arg2) {
6992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6993     return 0;
6994   }
6995   {
6996     try {
6997       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6998     } catch (std::out_of_range& e) {
6999       {
7000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (std::exception& e) {
7003       {
7004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7005       };
7006     } catch (...) {
7007       {
7008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7009       };
7010     }
7011   }
7012   jresult = (void *)result;
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7018   void * jresult ;
7019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7020   Dali::Vector4 *arg2 = 0 ;
7021   Dali::Vector4 result;
7022
7023   arg1 = (Dali::Vector4 *)jarg1;
7024   arg2 = (Dali::Vector4 *)jarg2;
7025   if (!arg2) {
7026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7027     return 0;
7028   }
7029   {
7030     try {
7031       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7032     } catch (std::out_of_range& e) {
7033       {
7034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7035       };
7036     } catch (std::exception& e) {
7037       {
7038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7039       };
7040     } catch (...) {
7041       {
7042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7043       };
7044     }
7045   }
7046   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7047   return jresult;
7048 }
7049
7050
7051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7052   void * jresult ;
7053   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7054   float arg2 ;
7055   Dali::Vector4 result;
7056
7057   arg1 = (Dali::Vector4 *)jarg1;
7058   arg2 = (float)jarg2;
7059   {
7060     try {
7061       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7062     } catch (std::out_of_range& e) {
7063       {
7064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (std::exception& e) {
7067       {
7068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7069       };
7070     } catch (...) {
7071       {
7072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7073       };
7074     }
7075   }
7076   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7077   return jresult;
7078 }
7079
7080
7081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7082   void * jresult ;
7083   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7084   Dali::Vector4 *arg2 = 0 ;
7085   Dali::Vector4 *result = 0 ;
7086
7087   arg1 = (Dali::Vector4 *)jarg1;
7088   arg2 = (Dali::Vector4 *)jarg2;
7089   if (!arg2) {
7090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7091     return 0;
7092   }
7093   {
7094     try {
7095       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7096     } catch (std::out_of_range& e) {
7097       {
7098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7099       };
7100     } catch (std::exception& e) {
7101       {
7102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7103       };
7104     } catch (...) {
7105       {
7106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7107       };
7108     }
7109   }
7110   jresult = (void *)result;
7111   return jresult;
7112 }
7113
7114
7115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7116   void * jresult ;
7117   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7118   float arg2 ;
7119   Dali::Vector4 *result = 0 ;
7120
7121   arg1 = (Dali::Vector4 *)jarg1;
7122   arg2 = (float)jarg2;
7123   {
7124     try {
7125       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7126     } catch (std::out_of_range& e) {
7127       {
7128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7129       };
7130     } catch (std::exception& e) {
7131       {
7132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7133       };
7134     } catch (...) {
7135       {
7136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7137       };
7138     }
7139   }
7140   jresult = (void *)result;
7141   return jresult;
7142 }
7143
7144
7145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7146   void * jresult ;
7147   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7148   Dali::Vector4 *arg2 = 0 ;
7149   Dali::Vector4 result;
7150
7151   arg1 = (Dali::Vector4 *)jarg1;
7152   arg2 = (Dali::Vector4 *)jarg2;
7153   if (!arg2) {
7154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7155     return 0;
7156   }
7157   {
7158     try {
7159       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7160     } catch (std::out_of_range& e) {
7161       {
7162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7163       };
7164     } catch (std::exception& e) {
7165       {
7166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7167       };
7168     } catch (...) {
7169       {
7170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7171       };
7172     }
7173   }
7174   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7180   void * jresult ;
7181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7182   float arg2 ;
7183   Dali::Vector4 result;
7184
7185   arg1 = (Dali::Vector4 *)jarg1;
7186   arg2 = (float)jarg2;
7187   {
7188     try {
7189       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7190     } catch (std::out_of_range& e) {
7191       {
7192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7193       };
7194     } catch (std::exception& e) {
7195       {
7196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (...) {
7199       {
7200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7201       };
7202     }
7203   }
7204   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7205   return jresult;
7206 }
7207
7208
7209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7210   void * jresult ;
7211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7212   Dali::Vector4 *arg2 = 0 ;
7213   Dali::Vector4 *result = 0 ;
7214
7215   arg1 = (Dali::Vector4 *)jarg1;
7216   arg2 = (Dali::Vector4 *)jarg2;
7217   if (!arg2) {
7218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7219     return 0;
7220   }
7221   {
7222     try {
7223       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7224     } catch (std::out_of_range& e) {
7225       {
7226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7227       };
7228     } catch (std::exception& e) {
7229       {
7230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7231       };
7232     } catch (...) {
7233       {
7234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7235       };
7236     }
7237   }
7238   jresult = (void *)result;
7239   return jresult;
7240 }
7241
7242
7243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7244   void * jresult ;
7245   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7246   float arg2 ;
7247   Dali::Vector4 *result = 0 ;
7248
7249   arg1 = (Dali::Vector4 *)jarg1;
7250   arg2 = (float)jarg2;
7251   {
7252     try {
7253       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7254     } catch (std::out_of_range& e) {
7255       {
7256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (std::exception& e) {
7259       {
7260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7261       };
7262     } catch (...) {
7263       {
7264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7265       };
7266     }
7267   }
7268   jresult = (void *)result;
7269   return jresult;
7270 }
7271
7272
7273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7274   void * jresult ;
7275   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7276   Dali::Vector4 result;
7277
7278   arg1 = (Dali::Vector4 *)jarg1;
7279   {
7280     try {
7281       result = ((Dali::Vector4 const *)arg1)->operator -();
7282     } catch (std::out_of_range& e) {
7283       {
7284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (std::exception& e) {
7287       {
7288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7289       };
7290     } catch (...) {
7291       {
7292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7293       };
7294     }
7295   }
7296   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7297   return jresult;
7298 }
7299
7300
7301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7302   unsigned int jresult ;
7303   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7304   Dali::Vector4 *arg2 = 0 ;
7305   bool result;
7306
7307   arg1 = (Dali::Vector4 *)jarg1;
7308   arg2 = (Dali::Vector4 *)jarg2;
7309   if (!arg2) {
7310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7311     return 0;
7312   }
7313   {
7314     try {
7315       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7316     } catch (std::out_of_range& e) {
7317       {
7318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (std::exception& e) {
7321       {
7322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330   jresult = result;
7331   return jresult;
7332 }
7333
7334
7335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7336   unsigned int jresult ;
7337   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7338   Dali::Vector4 *arg2 = 0 ;
7339   bool result;
7340
7341   arg1 = (Dali::Vector4 *)jarg1;
7342   arg2 = (Dali::Vector4 *)jarg2;
7343   if (!arg2) {
7344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7345     return 0;
7346   }
7347   {
7348     try {
7349       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7350     } catch (std::out_of_range& e) {
7351       {
7352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (std::exception& e) {
7355       {
7356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364   jresult = result;
7365   return jresult;
7366 }
7367
7368
7369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7370   float jresult ;
7371   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7372   unsigned int arg2 ;
7373   float *result = 0 ;
7374
7375   arg1 = (Dali::Vector4 *)jarg1;
7376   arg2 = (unsigned int)jarg2;
7377   {
7378     try {
7379       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7380     } catch (std::out_of_range& e) {
7381       {
7382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (std::exception& e) {
7385       {
7386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394   jresult = *result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7400   float jresult ;
7401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7402   Dali::Vector3 *arg2 = 0 ;
7403   float result;
7404
7405   arg1 = (Dali::Vector4 *)jarg1;
7406   arg2 = (Dali::Vector3 *)jarg2;
7407   if (!arg2) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7414     } catch (std::out_of_range& e) {
7415       {
7416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (std::exception& e) {
7419       {
7420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428   jresult = result;
7429   return jresult;
7430 }
7431
7432
7433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7434   float jresult ;
7435   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7436   Dali::Vector4 *arg2 = 0 ;
7437   float result;
7438
7439   arg1 = (Dali::Vector4 *)jarg1;
7440   arg2 = (Dali::Vector4 *)jarg2;
7441   if (!arg2) {
7442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7443     return 0;
7444   }
7445   {
7446     try {
7447       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7448     } catch (std::out_of_range& e) {
7449       {
7450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (std::exception& e) {
7453       {
7454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7455       };
7456     } catch (...) {
7457       {
7458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7459       };
7460     }
7461   }
7462   jresult = result;
7463   return jresult;
7464 }
7465
7466
7467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7468   float jresult ;
7469   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7470   Dali::Vector4 *arg2 = 0 ;
7471   float result;
7472
7473   arg1 = (Dali::Vector4 *)jarg1;
7474   arg2 = (Dali::Vector4 *)jarg2;
7475   if (!arg2) {
7476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7477     return 0;
7478   }
7479   {
7480     try {
7481       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7482     } catch (std::out_of_range& e) {
7483       {
7484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (std::exception& e) {
7487       {
7488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7489       };
7490     } catch (...) {
7491       {
7492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7493       };
7494     }
7495   }
7496   jresult = result;
7497   return jresult;
7498 }
7499
7500
7501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7502   void * jresult ;
7503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7504   Dali::Vector4 *arg2 = 0 ;
7505   Dali::Vector4 result;
7506
7507   arg1 = (Dali::Vector4 *)jarg1;
7508   arg2 = (Dali::Vector4 *)jarg2;
7509   if (!arg2) {
7510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7511     return 0;
7512   }
7513   {
7514     try {
7515       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7516     } catch (std::out_of_range& e) {
7517       {
7518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7519       };
7520     } catch (std::exception& e) {
7521       {
7522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7527       };
7528     }
7529   }
7530   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7536   float jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   float result;
7539
7540   arg1 = (Dali::Vector4 *)jarg1;
7541   {
7542     try {
7543       result = (float)((Dali::Vector4 const *)arg1)->Length();
7544     } catch (std::out_of_range& e) {
7545       {
7546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (std::exception& e) {
7549       {
7550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (...) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7555       };
7556     }
7557   }
7558   jresult = result;
7559   return jresult;
7560 }
7561
7562
7563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7564   float jresult ;
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float result;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   {
7570     try {
7571       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7572     } catch (std::out_of_range& e) {
7573       {
7574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7575       };
7576     } catch (std::exception& e) {
7577       {
7578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (...) {
7581       {
7582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7583       };
7584     }
7585   }
7586   jresult = result;
7587   return jresult;
7588 }
7589
7590
7591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7593
7594   arg1 = (Dali::Vector4 *)jarg1;
7595   {
7596     try {
7597       (arg1)->Normalize();
7598     } catch (std::out_of_range& e) {
7599       {
7600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7601       };
7602     } catch (std::exception& e) {
7603       {
7604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7605       };
7606     } catch (...) {
7607       {
7608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7609       };
7610     }
7611   }
7612 }
7613
7614
7615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7616   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7617   Dali::Vector4 *arg2 = 0 ;
7618   Dali::Vector4 *arg3 = 0 ;
7619
7620   arg1 = (Dali::Vector4 *)jarg1;
7621   arg2 = (Dali::Vector4 *)jarg2;
7622   if (!arg2) {
7623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7624     return ;
7625   }
7626   arg3 = (Dali::Vector4 *)jarg3;
7627   if (!arg3) {
7628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7629     return ;
7630   }
7631   {
7632     try {
7633       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7634     } catch (std::out_of_range& e) {
7635       {
7636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7637       };
7638     } catch (std::exception& e) {
7639       {
7640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7641       };
7642     } catch (...) {
7643       {
7644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7645       };
7646     }
7647   }
7648 }
7649
7650
7651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7652   void * jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   {
7658     try {
7659       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7660     } catch (std::out_of_range& e) {
7661       {
7662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7663       };
7664     } catch (std::exception& e) {
7665       {
7666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (...) {
7669       {
7670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7671       };
7672     }
7673   }
7674   jresult = (void *)result;
7675   return jresult;
7676 }
7677
7678
7679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7681   float arg2 ;
7682
7683   arg1 = (Dali::Vector4 *)jarg1;
7684   arg2 = (float)jarg2;
7685   if (arg1) (arg1)->x = arg2;
7686 }
7687
7688
7689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7690   float jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   float result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   result = (float) ((arg1)->x);
7696   jresult = result;
7697   return jresult;
7698 }
7699
7700
7701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7703   float arg2 ;
7704
7705   arg1 = (Dali::Vector4 *)jarg1;
7706   arg2 = (float)jarg2;
7707   if (arg1) (arg1)->r = arg2;
7708 }
7709
7710
7711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7712   float jresult ;
7713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7714   float result;
7715
7716   arg1 = (Dali::Vector4 *)jarg1;
7717   result = (float) ((arg1)->r);
7718   jresult = result;
7719   return jresult;
7720 }
7721
7722
7723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   float arg2 ;
7726
7727   arg1 = (Dali::Vector4 *)jarg1;
7728   arg2 = (float)jarg2;
7729   if (arg1) (arg1)->s = arg2;
7730 }
7731
7732
7733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7734   float jresult ;
7735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7736   float result;
7737
7738   arg1 = (Dali::Vector4 *)jarg1;
7739   result = (float) ((arg1)->s);
7740   jresult = result;
7741   return jresult;
7742 }
7743
7744
7745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7747   float arg2 ;
7748
7749   arg1 = (Dali::Vector4 *)jarg1;
7750   arg2 = (float)jarg2;
7751   if (arg1) (arg1)->y = arg2;
7752 }
7753
7754
7755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7756   float jresult ;
7757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7758   float result;
7759
7760   arg1 = (Dali::Vector4 *)jarg1;
7761   result = (float) ((arg1)->y);
7762   jresult = result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   float arg2 ;
7770
7771   arg1 = (Dali::Vector4 *)jarg1;
7772   arg2 = (float)jarg2;
7773   if (arg1) (arg1)->g = arg2;
7774 }
7775
7776
7777 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7778   float jresult ;
7779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7780   float result;
7781
7782   arg1 = (Dali::Vector4 *)jarg1;
7783   result = (float) ((arg1)->g);
7784   jresult = result;
7785   return jresult;
7786 }
7787
7788
7789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7791   float arg2 ;
7792
7793   arg1 = (Dali::Vector4 *)jarg1;
7794   arg2 = (float)jarg2;
7795   if (arg1) (arg1)->t = arg2;
7796 }
7797
7798
7799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7800   float jresult ;
7801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7802   float result;
7803
7804   arg1 = (Dali::Vector4 *)jarg1;
7805   result = (float) ((arg1)->t);
7806   jresult = result;
7807   return jresult;
7808 }
7809
7810
7811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7812   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7813   float arg2 ;
7814
7815   arg1 = (Dali::Vector4 *)jarg1;
7816   arg2 = (float)jarg2;
7817   if (arg1) (arg1)->z = arg2;
7818 }
7819
7820
7821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7822   float jresult ;
7823   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7824   float result;
7825
7826   arg1 = (Dali::Vector4 *)jarg1;
7827   result = (float) ((arg1)->z);
7828   jresult = result;
7829   return jresult;
7830 }
7831
7832
7833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7835   float arg2 ;
7836
7837   arg1 = (Dali::Vector4 *)jarg1;
7838   arg2 = (float)jarg2;
7839   if (arg1) (arg1)->b = arg2;
7840 }
7841
7842
7843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7844   float jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   float result;
7847
7848   arg1 = (Dali::Vector4 *)jarg1;
7849   result = (float) ((arg1)->b);
7850   jresult = result;
7851   return jresult;
7852 }
7853
7854
7855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7856   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7857   float arg2 ;
7858
7859   arg1 = (Dali::Vector4 *)jarg1;
7860   arg2 = (float)jarg2;
7861   if (arg1) (arg1)->p = arg2;
7862 }
7863
7864
7865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7866   float jresult ;
7867   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7868   float result;
7869
7870   arg1 = (Dali::Vector4 *)jarg1;
7871   result = (float) ((arg1)->p);
7872   jresult = result;
7873   return jresult;
7874 }
7875
7876
7877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7878   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7879   float arg2 ;
7880
7881   arg1 = (Dali::Vector4 *)jarg1;
7882   arg2 = (float)jarg2;
7883   if (arg1) (arg1)->w = arg2;
7884 }
7885
7886
7887 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7888   float jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float result;
7891
7892   arg1 = (Dali::Vector4 *)jarg1;
7893   result = (float) ((arg1)->w);
7894   jresult = result;
7895   return jresult;
7896 }
7897
7898
7899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7900   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7901   float arg2 ;
7902
7903   arg1 = (Dali::Vector4 *)jarg1;
7904   arg2 = (float)jarg2;
7905   if (arg1) (arg1)->a = arg2;
7906 }
7907
7908
7909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7910   float jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   float result;
7913
7914   arg1 = (Dali::Vector4 *)jarg1;
7915   result = (float) ((arg1)->a);
7916   jresult = result;
7917   return jresult;
7918 }
7919
7920
7921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7922   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7923   float arg2 ;
7924
7925   arg1 = (Dali::Vector4 *)jarg1;
7926   arg2 = (float)jarg2;
7927   if (arg1) (arg1)->q = arg2;
7928 }
7929
7930
7931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7932   float jresult ;
7933   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7934   float result;
7935
7936   arg1 = (Dali::Vector4 *)jarg1;
7937   result = (float) ((arg1)->q);
7938   jresult = result;
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   {
7948     try {
7949       delete arg1;
7950     } catch (std::out_of_range& e) {
7951       {
7952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7953       };
7954     } catch (std::exception& e) {
7955       {
7956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7957       };
7958     } catch (...) {
7959       {
7960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7961       };
7962     }
7963   }
7964 }
7965
7966
7967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7968   void * jresult ;
7969   Dali::Vector4 *arg1 = 0 ;
7970   Dali::Vector4 *arg2 = 0 ;
7971   Dali::Vector4 result;
7972
7973   arg1 = (Dali::Vector4 *)jarg1;
7974   if (!arg1) {
7975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7976     return 0;
7977   }
7978   arg2 = (Dali::Vector4 *)jarg2;
7979   if (!arg2) {
7980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7981     return 0;
7982   }
7983   {
7984     try {
7985       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7986     } catch (std::out_of_range& e) {
7987       {
7988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (std::exception& e) {
7991       {
7992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (...) {
7995       {
7996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7997       };
7998     }
7999   }
8000   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8001   return jresult;
8002 }
8003
8004
8005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8006   void * jresult ;
8007   Dali::Vector4 *arg1 = 0 ;
8008   Dali::Vector4 *arg2 = 0 ;
8009   Dali::Vector4 result;
8010
8011   arg1 = (Dali::Vector4 *)jarg1;
8012   if (!arg1) {
8013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8014     return 0;
8015   }
8016   arg2 = (Dali::Vector4 *)jarg2;
8017   if (!arg2) {
8018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8019     return 0;
8020   }
8021   {
8022     try {
8023       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8024     } catch (std::out_of_range& e) {
8025       {
8026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8027       };
8028     } catch (std::exception& e) {
8029       {
8030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (...) {
8033       {
8034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8035       };
8036     }
8037   }
8038   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8039   return jresult;
8040 }
8041
8042
8043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8044   void * jresult ;
8045   Dali::Vector4 *arg1 = 0 ;
8046   float *arg2 = 0 ;
8047   float *arg3 = 0 ;
8048   float temp2 ;
8049   float temp3 ;
8050   Dali::Vector4 result;
8051
8052   arg1 = (Dali::Vector4 *)jarg1;
8053   if (!arg1) {
8054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8055     return 0;
8056   }
8057   temp2 = (float)jarg2;
8058   arg2 = &temp2;
8059   temp3 = (float)jarg3;
8060   arg3 = &temp3;
8061   {
8062     try {
8063       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8064     } catch (std::out_of_range& e) {
8065       {
8066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (std::exception& e) {
8069       {
8070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (...) {
8073       {
8074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8075       };
8076     }
8077   }
8078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8079   return jresult;
8080 }
8081
8082
8083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8084   void * jresult ;
8085   Dali::Uint16Pair *result = 0 ;
8086
8087   {
8088     try {
8089       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8090     } catch (std::out_of_range& e) {
8091       {
8092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8093       };
8094     } catch (std::exception& e) {
8095       {
8096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8097       };
8098     } catch (...) {
8099       {
8100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8101       };
8102     }
8103   }
8104   jresult = (void *)result;
8105   return jresult;
8106 }
8107
8108
8109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8110   void * jresult ;
8111   uint32_t arg1 ;
8112   uint32_t arg2 ;
8113   Dali::Uint16Pair *result = 0 ;
8114
8115   arg1 = (uint32_t)jarg1;
8116   arg2 = (uint32_t)jarg2;
8117   {
8118     try {
8119       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8120     } catch (std::out_of_range& e) {
8121       {
8122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8123       };
8124     } catch (std::exception& e) {
8125       {
8126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8127       };
8128     } catch (...) {
8129       {
8130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8131       };
8132     }
8133   }
8134   jresult = (void *)result;
8135   return jresult;
8136 }
8137
8138
8139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8140   void * jresult ;
8141   Dali::Uint16Pair *arg1 = 0 ;
8142   Dali::Uint16Pair *result = 0 ;
8143
8144   arg1 = (Dali::Uint16Pair *)jarg1;
8145   if (!arg1) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (...) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8163       };
8164     }
8165   }
8166   jresult = (void *)result;
8167   return jresult;
8168 }
8169
8170
8171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8172   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8173   uint16_t arg2 ;
8174
8175   arg1 = (Dali::Uint16Pair *)jarg1;
8176   arg2 = (uint16_t)jarg2;
8177   {
8178     try {
8179       (arg1)->SetWidth(arg2);
8180     } catch (std::out_of_range& e) {
8181       {
8182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8183       };
8184     } catch (std::exception& e) {
8185       {
8186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8187       };
8188     } catch (...) {
8189       {
8190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8191       };
8192     }
8193   }
8194 }
8195
8196
8197 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8198   unsigned short jresult ;
8199   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8200   uint16_t result;
8201
8202   arg1 = (Dali::Uint16Pair *)jarg1;
8203   {
8204     try {
8205       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8206     } catch (std::out_of_range& e) {
8207       {
8208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8209       };
8210     } catch (std::exception& e) {
8211       {
8212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8213       };
8214     } catch (...) {
8215       {
8216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8217       };
8218     }
8219   }
8220   jresult = result;
8221   return jresult;
8222 }
8223
8224
8225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8226   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8227   uint16_t arg2 ;
8228
8229   arg1 = (Dali::Uint16Pair *)jarg1;
8230   arg2 = (uint16_t)jarg2;
8231   {
8232     try {
8233       (arg1)->SetHeight(arg2);
8234     } catch (std::out_of_range& e) {
8235       {
8236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8237       };
8238     } catch (std::exception& e) {
8239       {
8240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8241       };
8242     } catch (...) {
8243       {
8244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8245       };
8246     }
8247   }
8248 }
8249
8250
8251 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8252   unsigned short jresult ;
8253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8254   uint16_t result;
8255
8256   arg1 = (Dali::Uint16Pair *)jarg1;
8257   {
8258     try {
8259       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8267       };
8268     } catch (...) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8271       };
8272     }
8273   }
8274   jresult = result;
8275   return jresult;
8276 }
8277
8278
8279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8281   uint16_t arg2 ;
8282
8283   arg1 = (Dali::Uint16Pair *)jarg1;
8284   arg2 = (uint16_t)jarg2;
8285   {
8286     try {
8287       (arg1)->SetX(arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8295       };
8296     } catch (...) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8299       };
8300     }
8301   }
8302 }
8303
8304
8305 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8306   unsigned short jresult ;
8307   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8308   uint16_t result;
8309
8310   arg1 = (Dali::Uint16Pair *)jarg1;
8311   {
8312     try {
8313       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8314     } catch (std::out_of_range& e) {
8315       {
8316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8317       };
8318     } catch (std::exception& e) {
8319       {
8320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8321       };
8322     } catch (...) {
8323       {
8324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8325       };
8326     }
8327   }
8328   jresult = result;
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8334   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8335   uint16_t arg2 ;
8336
8337   arg1 = (Dali::Uint16Pair *)jarg1;
8338   arg2 = (uint16_t)jarg2;
8339   {
8340     try {
8341       (arg1)->SetY(arg2);
8342     } catch (std::out_of_range& e) {
8343       {
8344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8345       };
8346     } catch (std::exception& e) {
8347       {
8348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8349       };
8350     } catch (...) {
8351       {
8352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8353       };
8354     }
8355   }
8356 }
8357
8358
8359 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8360   unsigned short jresult ;
8361   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8362   uint16_t result;
8363
8364   arg1 = (Dali::Uint16Pair *)jarg1;
8365   {
8366     try {
8367       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (...) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8379       };
8380     }
8381   }
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8388   void * jresult ;
8389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8390   Dali::Uint16Pair *arg2 = 0 ;
8391   Dali::Uint16Pair *result = 0 ;
8392
8393   arg1 = (Dali::Uint16Pair *)jarg1;
8394   arg2 = (Dali::Uint16Pair *)jarg2;
8395   if (!arg2) {
8396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8397     return 0;
8398   }
8399   {
8400     try {
8401       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8402     } catch (std::out_of_range& e) {
8403       {
8404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8405       };
8406     } catch (std::exception& e) {
8407       {
8408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (...) {
8411       {
8412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8413       };
8414     }
8415   }
8416   jresult = (void *)result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8422   unsigned int jresult ;
8423   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8424   Dali::Uint16Pair *arg2 = 0 ;
8425   bool result;
8426
8427   arg1 = (Dali::Uint16Pair *)jarg1;
8428   arg2 = (Dali::Uint16Pair *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8436     } catch (std::out_of_range& e) {
8437       {
8438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8439       };
8440     } catch (std::exception& e) {
8441       {
8442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8447       };
8448     }
8449   }
8450   jresult = result;
8451   return jresult;
8452 }
8453
8454
8455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8456   unsigned int jresult ;
8457   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8458   Dali::Uint16Pair *arg2 = 0 ;
8459   bool result;
8460
8461   arg1 = (Dali::Uint16Pair *)jarg1;
8462   arg2 = (Dali::Uint16Pair *)jarg2;
8463   if (!arg2) {
8464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8465     return 0;
8466   }
8467   {
8468     try {
8469       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8470     } catch (std::out_of_range& e) {
8471       {
8472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8473       };
8474     } catch (std::exception& e) {
8475       {
8476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8477       };
8478     } catch (...) {
8479       {
8480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8481       };
8482     }
8483   }
8484   jresult = result;
8485   return jresult;
8486 }
8487
8488
8489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8490   unsigned int jresult ;
8491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8492   Dali::Uint16Pair *arg2 = 0 ;
8493   bool result;
8494
8495   arg1 = (Dali::Uint16Pair *)jarg1;
8496   arg2 = (Dali::Uint16Pair *)jarg2;
8497   if (!arg2) {
8498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8499     return 0;
8500   }
8501   {
8502     try {
8503       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (...) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8515       };
8516     }
8517   }
8518   jresult = result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8524   unsigned int jresult ;
8525   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8526   Dali::Uint16Pair *arg2 = 0 ;
8527   bool result;
8528
8529   arg1 = (Dali::Uint16Pair *)jarg1;
8530   arg2 = (Dali::Uint16Pair *)jarg2;
8531   if (!arg2) {
8532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8533     return 0;
8534   }
8535   {
8536     try {
8537       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8538     } catch (std::out_of_range& e) {
8539       {
8540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8541       };
8542     } catch (std::exception& e) {
8543       {
8544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8545       };
8546     } catch (...) {
8547       {
8548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8549       };
8550     }
8551   }
8552   jresult = result;
8553   return jresult;
8554 }
8555
8556
8557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8558   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8559
8560   arg1 = (Dali::Uint16Pair *)jarg1;
8561   {
8562     try {
8563       delete arg1;
8564     } catch (std::out_of_range& e) {
8565       {
8566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8567       };
8568     } catch (std::exception& e) {
8569       {
8570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8571       };
8572     } catch (...) {
8573       {
8574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8575       };
8576     }
8577   }
8578 }
8579
8580
8581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8582   void * jresult ;
8583   Dali::Degree *result = 0 ;
8584
8585   {
8586     try {
8587       result = (Dali::Degree *)new Dali::Degree();
8588     } catch (std::out_of_range& e) {
8589       {
8590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8591       };
8592     } catch (std::exception& e) {
8593       {
8594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8595       };
8596     } catch (...) {
8597       {
8598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8599       };
8600     }
8601   }
8602   jresult = (void *)result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8608   void * jresult ;
8609   float arg1 ;
8610   Dali::Degree *result = 0 ;
8611
8612   arg1 = (float)jarg1;
8613   {
8614     try {
8615       result = (Dali::Degree *)new Dali::Degree(arg1);
8616     } catch (std::out_of_range& e) {
8617       {
8618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8619       };
8620     } catch (std::exception& e) {
8621       {
8622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8623       };
8624     } catch (...) {
8625       {
8626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8627       };
8628     }
8629   }
8630   jresult = (void *)result;
8631   return jresult;
8632 }
8633
8634
8635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8636   void * jresult ;
8637   Dali::Radian arg1 ;
8638   Dali::Radian *argp1 ;
8639   Dali::Degree *result = 0 ;
8640
8641   argp1 = (Dali::Radian *)jarg1;
8642   if (!argp1) {
8643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8644     return 0;
8645   }
8646   arg1 = *argp1;
8647   {
8648     try {
8649       result = (Dali::Degree *)new Dali::Degree(arg1);
8650     } catch (std::out_of_range& e) {
8651       {
8652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8653       };
8654     } catch (std::exception& e) {
8655       {
8656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8657       };
8658     } catch (...) {
8659       {
8660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8661       };
8662     }
8663   }
8664   jresult = (void *)result;
8665   return jresult;
8666 }
8667
8668
8669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8670   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8671   float arg2 ;
8672
8673   arg1 = (Dali::Degree *)jarg1;
8674   arg2 = (float)jarg2;
8675   if (arg1) (arg1)->degree = arg2;
8676 }
8677
8678
8679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8680   float jresult ;
8681   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8682   float result;
8683
8684   arg1 = (Dali::Degree *)jarg1;
8685   result = (float) ((arg1)->degree);
8686   jresult = result;
8687   return jresult;
8688 }
8689
8690
8691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8692   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8693
8694   arg1 = (Dali::Degree *)jarg1;
8695   {
8696     try {
8697       delete arg1;
8698     } catch (std::out_of_range& e) {
8699       {
8700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8701       };
8702     } catch (std::exception& e) {
8703       {
8704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8705       };
8706     } catch (...) {
8707       {
8708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8709       };
8710     }
8711   }
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_360;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_315;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8736   void * jresult ;
8737   Dali::Radian *result = 0 ;
8738
8739   result = (Dali::Radian *)&Dali::ANGLE_270;
8740   jresult = (void *)result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8746   void * jresult ;
8747   Dali::Radian *result = 0 ;
8748
8749   result = (Dali::Radian *)&Dali::ANGLE_225;
8750   jresult = (void *)result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8756   void * jresult ;
8757   Dali::Radian *result = 0 ;
8758
8759   result = (Dali::Radian *)&Dali::ANGLE_180;
8760   jresult = (void *)result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8766   void * jresult ;
8767   Dali::Radian *result = 0 ;
8768
8769   result = (Dali::Radian *)&Dali::ANGLE_135;
8770   jresult = (void *)result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8776   void * jresult ;
8777   Dali::Radian *result = 0 ;
8778
8779   result = (Dali::Radian *)&Dali::ANGLE_120;
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8786   void * jresult ;
8787   Dali::Radian *result = 0 ;
8788
8789   result = (Dali::Radian *)&Dali::ANGLE_90;
8790   jresult = (void *)result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8796   void * jresult ;
8797   Dali::Radian *result = 0 ;
8798
8799   result = (Dali::Radian *)&Dali::ANGLE_60;
8800   jresult = (void *)result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8806   void * jresult ;
8807   Dali::Radian *result = 0 ;
8808
8809   result = (Dali::Radian *)&Dali::ANGLE_45;
8810   jresult = (void *)result;
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8816   void * jresult ;
8817   Dali::Radian *result = 0 ;
8818
8819   result = (Dali::Radian *)&Dali::ANGLE_30;
8820   jresult = (void *)result;
8821   return jresult;
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8826   void * jresult ;
8827   Dali::Radian *result = 0 ;
8828
8829   result = (Dali::Radian *)&Dali::ANGLE_0;
8830   jresult = (void *)result;
8831   return jresult;
8832 }
8833
8834
8835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8836   unsigned int jresult ;
8837   Dali::Degree *arg1 = 0 ;
8838   Dali::Degree *arg2 = 0 ;
8839   bool result;
8840
8841   arg1 = (Dali::Degree *)jarg1;
8842   if (!arg1) {
8843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8844     return 0;
8845   }
8846   arg2 = (Dali::Degree *)jarg2;
8847   if (!arg2) {
8848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8849     return 0;
8850   }
8851   {
8852     try {
8853       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8854     } catch (std::out_of_range& e) {
8855       {
8856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8857       };
8858     } catch (std::exception& e) {
8859       {
8860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (...) {
8863       {
8864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8865       };
8866     }
8867   }
8868   jresult = result;
8869   return jresult;
8870 }
8871
8872
8873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8874   unsigned int jresult ;
8875   Dali::Degree *arg1 = 0 ;
8876   Dali::Degree *arg2 = 0 ;
8877   bool result;
8878
8879   arg1 = (Dali::Degree *)jarg1;
8880   if (!arg1) {
8881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8882     return 0;
8883   }
8884   arg2 = (Dali::Degree *)jarg2;
8885   if (!arg2) {
8886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8887     return 0;
8888   }
8889   {
8890     try {
8891       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8892     } catch (std::out_of_range& e) {
8893       {
8894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (std::exception& e) {
8897       {
8898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906   jresult = result;
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8912   void * jresult ;
8913   Dali::Degree arg1 ;
8914   float arg2 ;
8915   float arg3 ;
8916   Dali::Degree *argp1 ;
8917   Dali::Degree result;
8918
8919   argp1 = (Dali::Degree *)jarg1;
8920   if (!argp1) {
8921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8922     return 0;
8923   }
8924   arg1 = *argp1;
8925   arg2 = (float)jarg2;
8926   arg3 = (float)jarg3;
8927   {
8928     try {
8929       result = Dali::Clamp(arg1,arg2,arg3);
8930     } catch (std::out_of_range& e) {
8931       {
8932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8933       };
8934     } catch (std::exception& e) {
8935       {
8936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (...) {
8939       {
8940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8941       };
8942     }
8943   }
8944   jresult = new Dali::Degree((const Dali::Degree &)result);
8945   return jresult;
8946 }
8947
8948
8949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8950   void * jresult ;
8951   Dali::Radian *result = 0 ;
8952
8953   {
8954     try {
8955       result = (Dali::Radian *)new Dali::Radian();
8956     } catch (std::out_of_range& e) {
8957       {
8958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8959       };
8960     } catch (std::exception& e) {
8961       {
8962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8963       };
8964     } catch (...) {
8965       {
8966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8967       };
8968     }
8969   }
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8976   void * jresult ;
8977   float arg1 ;
8978   Dali::Radian *result = 0 ;
8979
8980   arg1 = (float)jarg1;
8981   {
8982     try {
8983       result = (Dali::Radian *)new Dali::Radian(arg1);
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 void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9004   void * jresult ;
9005   Dali::Degree arg1 ;
9006   Dali::Degree *argp1 ;
9007   Dali::Radian *result = 0 ;
9008
9009   argp1 = (Dali::Degree *)jarg1;
9010   if (!argp1) {
9011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9012     return 0;
9013   }
9014   arg1 = *argp1;
9015   {
9016     try {
9017       result = (Dali::Radian *)new Dali::Radian(arg1);
9018     } catch (std::out_of_range& e) {
9019       {
9020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9021       };
9022     } catch (std::exception& e) {
9023       {
9024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9025       };
9026     } catch (...) {
9027       {
9028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9029       };
9030     }
9031   }
9032   jresult = (void *)result;
9033   return jresult;
9034 }
9035
9036
9037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9038   void * jresult ;
9039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9040   float arg2 ;
9041   Dali::Radian *result = 0 ;
9042
9043   arg1 = (Dali::Radian *)jarg1;
9044   arg2 = (float)jarg2;
9045   {
9046     try {
9047       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9048     } catch (std::out_of_range& e) {
9049       {
9050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9051       };
9052     } catch (std::exception& e) {
9053       {
9054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9055       };
9056     } catch (...) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9059       };
9060     }
9061   }
9062   jresult = (void *)result;
9063   return jresult;
9064 }
9065
9066
9067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9068   void * jresult ;
9069   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9070   Dali::Degree arg2 ;
9071   Dali::Degree *argp2 ;
9072   Dali::Radian *result = 0 ;
9073
9074   arg1 = (Dali::Radian *)jarg1;
9075   argp2 = (Dali::Degree *)jarg2;
9076   if (!argp2) {
9077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9078     return 0;
9079   }
9080   arg2 = *argp2;
9081   {
9082     try {
9083       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9084     } catch (std::out_of_range& e) {
9085       {
9086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9087       };
9088     } catch (std::exception& e) {
9089       {
9090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9091       };
9092     } catch (...) {
9093       {
9094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9095       };
9096     }
9097   }
9098   jresult = (void *)result;
9099   return jresult;
9100 }
9101
9102
9103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9104   float jresult ;
9105   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9106   float result;
9107
9108   arg1 = (Dali::Radian *)jarg1;
9109   {
9110     try {
9111       result = (float)((Dali::Radian const *)arg1)->operator float();
9112     } catch (std::out_of_range& e) {
9113       {
9114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9115       };
9116     } catch (std::exception& e) {
9117       {
9118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9119       };
9120     } catch (...) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9123       };
9124     }
9125   }
9126   jresult = result;
9127   return jresult;
9128 }
9129
9130
9131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9133   float arg2 ;
9134
9135   arg1 = (Dali::Radian *)jarg1;
9136   arg2 = (float)jarg2;
9137   if (arg1) (arg1)->radian = arg2;
9138 }
9139
9140
9141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9142   float jresult ;
9143   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9144   float result;
9145
9146   arg1 = (Dali::Radian *)jarg1;
9147   result = (float) ((arg1)->radian);
9148   jresult = result;
9149   return jresult;
9150 }
9151
9152
9153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9155
9156   arg1 = (Dali::Radian *)jarg1;
9157   {
9158     try {
9159       delete arg1;
9160     } catch (std::out_of_range& e) {
9161       {
9162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9163       };
9164     } catch (std::exception& e) {
9165       {
9166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9167       };
9168     } catch (...) {
9169       {
9170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9171       };
9172     }
9173   }
9174 }
9175
9176
9177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9178   unsigned int jresult ;
9179   Dali::Radian arg1 ;
9180   Dali::Radian arg2 ;
9181   Dali::Radian *argp1 ;
9182   Dali::Radian *argp2 ;
9183   bool result;
9184
9185   argp1 = (Dali::Radian *)jarg1;
9186   if (!argp1) {
9187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9188     return 0;
9189   }
9190   arg1 = *argp1;
9191   argp2 = (Dali::Radian *)jarg2;
9192   if (!argp2) {
9193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9194     return 0;
9195   }
9196   arg2 = *argp2;
9197   {
9198     try {
9199       result = (bool)Dali::operator ==(arg1,arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9207       };
9208     } catch (...) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9211       };
9212     }
9213   }
9214   jresult = result;
9215   return jresult;
9216 }
9217
9218
9219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9220   unsigned int jresult ;
9221   Dali::Radian arg1 ;
9222   Dali::Radian arg2 ;
9223   Dali::Radian *argp1 ;
9224   Dali::Radian *argp2 ;
9225   bool result;
9226
9227   argp1 = (Dali::Radian *)jarg1;
9228   if (!argp1) {
9229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9230     return 0;
9231   }
9232   arg1 = *argp1;
9233   argp2 = (Dali::Radian *)jarg2;
9234   if (!argp2) {
9235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9236     return 0;
9237   }
9238   arg2 = *argp2;
9239   {
9240     try {
9241       result = (bool)Dali::operator !=(arg1,arg2);
9242     } catch (std::out_of_range& e) {
9243       {
9244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9245       };
9246     } catch (std::exception& e) {
9247       {
9248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (...) {
9251       {
9252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9253       };
9254     }
9255   }
9256   jresult = result;
9257   return jresult;
9258 }
9259
9260
9261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9262   unsigned int jresult ;
9263   Dali::Radian arg1 ;
9264   Dali::Degree arg2 ;
9265   Dali::Radian *argp1 ;
9266   Dali::Degree *argp2 ;
9267   bool result;
9268
9269   argp1 = (Dali::Radian *)jarg1;
9270   if (!argp1) {
9271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9272     return 0;
9273   }
9274   arg1 = *argp1;
9275   argp2 = (Dali::Degree *)jarg2;
9276   if (!argp2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9278     return 0;
9279   }
9280   arg2 = *argp2;
9281   {
9282     try {
9283       result = (bool)Dali::operator ==(arg1,arg2);
9284     } catch (std::out_of_range& e) {
9285       {
9286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9287       };
9288     } catch (std::exception& e) {
9289       {
9290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (...) {
9293       {
9294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9295       };
9296     }
9297   }
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9304   unsigned int jresult ;
9305   Dali::Radian arg1 ;
9306   Dali::Degree arg2 ;
9307   Dali::Radian *argp1 ;
9308   Dali::Degree *argp2 ;
9309   bool result;
9310
9311   argp1 = (Dali::Radian *)jarg1;
9312   if (!argp1) {
9313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9314     return 0;
9315   }
9316   arg1 = *argp1;
9317   argp2 = (Dali::Degree *)jarg2;
9318   if (!argp2) {
9319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9320     return 0;
9321   }
9322   arg2 = *argp2;
9323   {
9324     try {
9325       result = (bool)Dali::operator !=(arg1,arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (...) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9337       };
9338     }
9339   }
9340   jresult = result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Degree arg1 ;
9348   Dali::Radian arg2 ;
9349   Dali::Degree *argp1 ;
9350   Dali::Radian *argp2 ;
9351   bool result;
9352
9353   argp1 = (Dali::Degree *)jarg1;
9354   if (!argp1) {
9355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9356     return 0;
9357   }
9358   arg1 = *argp1;
9359   argp2 = (Dali::Radian *)jarg2;
9360   if (!argp2) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9362     return 0;
9363   }
9364   arg2 = *argp2;
9365   {
9366     try {
9367       result = (bool)Dali::operator ==(arg1,arg2);
9368     } catch (std::out_of_range& e) {
9369       {
9370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9371       };
9372     } catch (std::exception& e) {
9373       {
9374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (...) {
9377       {
9378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9379       };
9380     }
9381   }
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Degree arg1 ;
9390   Dali::Radian arg2 ;
9391   Dali::Degree *argp1 ;
9392   Dali::Radian *argp2 ;
9393   bool result;
9394
9395   argp1 = (Dali::Degree *)jarg1;
9396   if (!argp1) {
9397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9398     return 0;
9399   }
9400   arg1 = *argp1;
9401   argp2 = (Dali::Radian *)jarg2;
9402   if (!argp2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9404     return 0;
9405   }
9406   arg2 = *argp2;
9407   {
9408     try {
9409       result = (bool)Dali::operator !=(arg1,arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (...) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9421       };
9422     }
9423   }
9424   jresult = result;
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9430   unsigned int jresult ;
9431   Dali::Radian arg1 ;
9432   Dali::Radian arg2 ;
9433   Dali::Radian *argp1 ;
9434   Dali::Radian *argp2 ;
9435   bool result;
9436
9437   argp1 = (Dali::Radian *)jarg1;
9438   if (!argp1) {
9439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9440     return 0;
9441   }
9442   arg1 = *argp1;
9443   argp2 = (Dali::Radian *)jarg2;
9444   if (!argp2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9446     return 0;
9447   }
9448   arg2 = *argp2;
9449   {
9450     try {
9451       result = (bool)Dali::operator >(arg1,arg2);
9452     } catch (std::out_of_range& e) {
9453       {
9454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (std::exception& e) {
9457       {
9458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466   jresult = result;
9467   return jresult;
9468 }
9469
9470
9471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9472   unsigned int jresult ;
9473   Dali::Radian arg1 ;
9474   Dali::Degree arg2 ;
9475   Dali::Radian *argp1 ;
9476   Dali::Degree *argp2 ;
9477   bool result;
9478
9479   argp1 = (Dali::Radian *)jarg1;
9480   if (!argp1) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9482     return 0;
9483   }
9484   arg1 = *argp1;
9485   argp2 = (Dali::Degree *)jarg2;
9486   if (!argp2) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9488     return 0;
9489   }
9490   arg2 = *argp2;
9491   {
9492     try {
9493       result = (bool)Dali::operator >(arg1,arg2);
9494     } catch (std::out_of_range& e) {
9495       {
9496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (std::exception& e) {
9499       {
9500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508   jresult = result;
9509   return jresult;
9510 }
9511
9512
9513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9514   unsigned int jresult ;
9515   Dali::Degree arg1 ;
9516   Dali::Radian arg2 ;
9517   Dali::Degree *argp1 ;
9518   Dali::Radian *argp2 ;
9519   bool result;
9520
9521   argp1 = (Dali::Degree *)jarg1;
9522   if (!argp1) {
9523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9524     return 0;
9525   }
9526   arg1 = *argp1;
9527   argp2 = (Dali::Radian *)jarg2;
9528   if (!argp2) {
9529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9530     return 0;
9531   }
9532   arg2 = *argp2;
9533   {
9534     try {
9535       result = (bool)Dali::operator >(arg1,arg2);
9536     } catch (std::out_of_range& e) {
9537       {
9538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (std::exception& e) {
9541       {
9542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9547       };
9548     }
9549   }
9550   jresult = result;
9551   return jresult;
9552 }
9553
9554
9555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9556   unsigned int jresult ;
9557   Dali::Radian arg1 ;
9558   Dali::Radian arg2 ;
9559   Dali::Radian *argp1 ;
9560   Dali::Radian *argp2 ;
9561   bool result;
9562
9563   argp1 = (Dali::Radian *)jarg1;
9564   if (!argp1) {
9565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9566     return 0;
9567   }
9568   arg1 = *argp1;
9569   argp2 = (Dali::Radian *)jarg2;
9570   if (!argp2) {
9571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9572     return 0;
9573   }
9574   arg2 = *argp2;
9575   {
9576     try {
9577       result = (bool)Dali::operator <(arg1,arg2);
9578     } catch (std::out_of_range& e) {
9579       {
9580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9581       };
9582     } catch (std::exception& e) {
9583       {
9584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (...) {
9587       {
9588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9589       };
9590     }
9591   }
9592   jresult = result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9598   unsigned int jresult ;
9599   Dali::Radian arg1 ;
9600   Dali::Degree arg2 ;
9601   Dali::Radian *argp1 ;
9602   Dali::Degree *argp2 ;
9603   bool result;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   argp2 = (Dali::Degree *)jarg2;
9612   if (!argp2) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9614     return 0;
9615   }
9616   arg2 = *argp2;
9617   {
9618     try {
9619       result = (bool)Dali::operator <(arg1,arg2);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (...) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9631       };
9632     }
9633   }
9634   jresult = result;
9635   return jresult;
9636 }
9637
9638
9639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9640   unsigned int jresult ;
9641   Dali::Degree arg1 ;
9642   Dali::Radian arg2 ;
9643   Dali::Degree *argp1 ;
9644   Dali::Radian *argp2 ;
9645   bool result;
9646
9647   argp1 = (Dali::Degree *)jarg1;
9648   if (!argp1) {
9649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9650     return 0;
9651   }
9652   arg1 = *argp1;
9653   argp2 = (Dali::Radian *)jarg2;
9654   if (!argp2) {
9655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9656     return 0;
9657   }
9658   arg2 = *argp2;
9659   {
9660     try {
9661       result = (bool)Dali::operator <(arg1,arg2);
9662     } catch (std::out_of_range& e) {
9663       {
9664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9665       };
9666     } catch (std::exception& e) {
9667       {
9668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9669       };
9670     } catch (...) {
9671       {
9672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9673       };
9674     }
9675   }
9676   jresult = result;
9677   return jresult;
9678 }
9679
9680
9681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9682   void * jresult ;
9683   Dali::Radian arg1 ;
9684   float arg2 ;
9685   Dali::Radian *argp1 ;
9686   Dali::Radian result;
9687
9688   argp1 = (Dali::Radian *)jarg1;
9689   if (!argp1) {
9690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9691     return 0;
9692   }
9693   arg1 = *argp1;
9694   arg2 = (float)jarg2;
9695   {
9696     try {
9697       result = Dali::operator *(arg1,arg2);
9698     } catch (std::out_of_range& e) {
9699       {
9700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (std::exception& e) {
9703       {
9704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9705       };
9706     } catch (...) {
9707       {
9708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9709       };
9710     }
9711   }
9712   jresult = new Dali::Radian((const Dali::Radian &)result);
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9718   void * jresult ;
9719   Dali::Radian arg1 ;
9720   Dali::Radian *argp1 ;
9721   Dali::Radian result;
9722
9723   argp1 = (Dali::Radian *)jarg1;
9724   if (!argp1) {
9725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9726     return 0;
9727   }
9728   arg1 = *argp1;
9729   {
9730     try {
9731       result = Dali::operator -(arg1);
9732     } catch (std::out_of_range& e) {
9733       {
9734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9735       };
9736     } catch (std::exception& e) {
9737       {
9738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (...) {
9741       {
9742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9743       };
9744     }
9745   }
9746   jresult = new Dali::Radian((const Dali::Radian &)result);
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9752   void * jresult ;
9753   Dali::Radian arg1 ;
9754   float arg2 ;
9755   float arg3 ;
9756   Dali::Radian *argp1 ;
9757   Dali::Radian result;
9758
9759   argp1 = (Dali::Radian *)jarg1;
9760   if (!argp1) {
9761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9762     return 0;
9763   }
9764   arg1 = *argp1;
9765   arg2 = (float)jarg2;
9766   arg3 = (float)jarg3;
9767   {
9768     try {
9769       result = Dali::Clamp(arg1,arg2,arg3);
9770     } catch (std::out_of_range& e) {
9771       {
9772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9773       };
9774     } catch (std::exception& e) {
9775       {
9776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9777       };
9778     } catch (...) {
9779       {
9780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9781       };
9782     }
9783   }
9784   jresult = new Dali::Radian((const Dali::Radian &)result);
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9790   void * jresult ;
9791   Dali::Quaternion *result = 0 ;
9792
9793   {
9794     try {
9795       result = (Dali::Quaternion *)new Dali::Quaternion();
9796     } catch (std::out_of_range& e) {
9797       {
9798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9799       };
9800     } catch (std::exception& e) {
9801       {
9802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9803       };
9804     } catch (...) {
9805       {
9806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9807       };
9808     }
9809   }
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9816   void * jresult ;
9817   Dali::Radian arg1 ;
9818   Dali::Vector3 *arg2 = 0 ;
9819   Dali::Radian *argp1 ;
9820   Dali::Quaternion *result = 0 ;
9821
9822   argp1 = (Dali::Radian *)jarg1;
9823   if (!argp1) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9825     return 0;
9826   }
9827   arg1 = *argp1;
9828   arg2 = (Dali::Vector3 *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850   jresult = (void *)result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9856   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9857
9858   arg1 = (Dali::Quaternion *)jarg1;
9859   {
9860     try {
9861       delete arg1;
9862     } catch (std::out_of_range& e) {
9863       {
9864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9865       };
9866     } catch (std::exception& e) {
9867       {
9868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9869       };
9870     } catch (...) {
9871       {
9872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9873       };
9874     }
9875   }
9876 }
9877
9878
9879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9880   void * jresult ;
9881   Dali::Quaternion *result = 0 ;
9882
9883   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9884   jresult = (void *)result;
9885   return jresult;
9886 }
9887
9888
9889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9890   unsigned int jresult ;
9891   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9892   bool result;
9893
9894   arg1 = (Dali::Quaternion *)jarg1;
9895   {
9896     try {
9897       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9898     } catch (std::out_of_range& e) {
9899       {
9900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9901       };
9902     } catch (std::exception& e) {
9903       {
9904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9905       };
9906     } catch (...) {
9907       {
9908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9909       };
9910     }
9911   }
9912   jresult = result;
9913   return jresult;
9914 }
9915
9916
9917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9918   unsigned int jresult ;
9919   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9920   Dali::Vector3 *arg2 = 0 ;
9921   Dali::Radian *arg3 = 0 ;
9922   bool result;
9923
9924   arg1 = (Dali::Quaternion *)jarg1;
9925   arg2 = (Dali::Vector3 *)jarg2;
9926   if (!arg2) {
9927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9928     return 0;
9929   }
9930   arg3 = (Dali::Radian *)jarg3;
9931   if (!arg3) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9938     } catch (std::out_of_range& e) {
9939       {
9940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (std::exception& e) {
9943       {
9944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9945       };
9946     } catch (...) {
9947       {
9948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9949       };
9950     }
9951   }
9952   jresult = result;
9953   return jresult;
9954 }
9955
9956
9957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9958   void * jresult ;
9959   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9960   Dali::Quaternion *arg2 = 0 ;
9961   Dali::Quaternion result;
9962
9963   arg1 = (Dali::Quaternion *)jarg1;
9964   arg2 = (Dali::Quaternion *)jarg2;
9965   if (!arg2) {
9966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9967     return 0;
9968   }
9969   {
9970     try {
9971       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9972     } catch (std::out_of_range& e) {
9973       {
9974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9975       };
9976     } catch (std::exception& e) {
9977       {
9978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (...) {
9981       {
9982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9983       };
9984     }
9985   }
9986   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9992   void * jresult ;
9993   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9994   Dali::Quaternion *arg2 = 0 ;
9995   Dali::Quaternion result;
9996
9997   arg1 = (Dali::Quaternion *)jarg1;
9998   arg2 = (Dali::Quaternion *)jarg2;
9999   if (!arg2) {
10000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10001     return 0;
10002   }
10003   {
10004     try {
10005       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10006     } catch (std::out_of_range& e) {
10007       {
10008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10009       };
10010     } catch (std::exception& e) {
10011       {
10012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10013       };
10014     } catch (...) {
10015       {
10016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10017       };
10018     }
10019   }
10020   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10026   void * jresult ;
10027   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10028   Dali::Quaternion *arg2 = 0 ;
10029   Dali::Quaternion result;
10030
10031   arg1 = (Dali::Quaternion *)jarg1;
10032   arg2 = (Dali::Quaternion *)jarg2;
10033   if (!arg2) {
10034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10035     return 0;
10036   }
10037   {
10038     try {
10039       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10040     } catch (std::out_of_range& e) {
10041       {
10042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (std::exception& e) {
10045       {
10046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10047       };
10048     } catch (...) {
10049       {
10050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10051       };
10052     }
10053   }
10054   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10055   return jresult;
10056 }
10057
10058
10059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10060   void * jresult ;
10061   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10062   Dali::Vector3 *arg2 = 0 ;
10063   Dali::Vector3 result;
10064
10065   arg1 = (Dali::Quaternion *)jarg1;
10066   arg2 = (Dali::Vector3 *)jarg2;
10067   if (!arg2) {
10068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10069     return 0;
10070   }
10071   {
10072     try {
10073       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10074     } catch (std::out_of_range& e) {
10075       {
10076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10077       };
10078     } catch (std::exception& e) {
10079       {
10080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10081       };
10082     } catch (...) {
10083       {
10084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10085       };
10086     }
10087   }
10088   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10089   return jresult;
10090 }
10091
10092
10093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10094   void * jresult ;
10095   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10096   Dali::Quaternion *arg2 = 0 ;
10097   Dali::Quaternion result;
10098
10099   arg1 = (Dali::Quaternion *)jarg1;
10100   arg2 = (Dali::Quaternion *)jarg2;
10101   if (!arg2) {
10102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10103     return 0;
10104   }
10105   {
10106     try {
10107       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10108     } catch (std::out_of_range& e) {
10109       {
10110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10111       };
10112     } catch (std::exception& e) {
10113       {
10114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10115       };
10116     } catch (...) {
10117       {
10118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10119       };
10120     }
10121   }
10122   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10123   return jresult;
10124 }
10125
10126
10127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10128   void * jresult ;
10129   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10130   float arg2 ;
10131   Dali::Quaternion result;
10132
10133   arg1 = (Dali::Quaternion *)jarg1;
10134   arg2 = (float)jarg2;
10135   {
10136     try {
10137       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10138     } catch (std::out_of_range& e) {
10139       {
10140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (std::exception& e) {
10143       {
10144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10158   void * jresult ;
10159   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10160   float arg2 ;
10161   Dali::Quaternion result;
10162
10163   arg1 = (Dali::Quaternion *)jarg1;
10164   arg2 = (float)jarg2;
10165   {
10166     try {
10167       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10168     } catch (std::out_of_range& e) {
10169       {
10170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10171       };
10172     } catch (std::exception& e) {
10173       {
10174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10175       };
10176     } catch (...) {
10177       {
10178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10179       };
10180     }
10181   }
10182   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10183   return jresult;
10184 }
10185
10186
10187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10188   void * jresult ;
10189   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10190   Dali::Quaternion result;
10191
10192   arg1 = (Dali::Quaternion *)jarg1;
10193   {
10194     try {
10195       result = ((Dali::Quaternion const *)arg1)->operator -();
10196     } catch (std::out_of_range& e) {
10197       {
10198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (std::exception& e) {
10201       {
10202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10207       };
10208     }
10209   }
10210   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10216   void * jresult ;
10217   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10218   Dali::Quaternion *arg2 = 0 ;
10219   Dali::Quaternion *result = 0 ;
10220
10221   arg1 = (Dali::Quaternion *)jarg1;
10222   arg2 = (Dali::Quaternion *)jarg2;
10223   if (!arg2) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10225     return 0;
10226   }
10227   {
10228     try {
10229       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (...) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10241       };
10242     }
10243   }
10244   jresult = (void *)result;
10245   return jresult;
10246 }
10247
10248
10249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10250   void * jresult ;
10251   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10252   Dali::Quaternion *arg2 = 0 ;
10253   Dali::Quaternion *result = 0 ;
10254
10255   arg1 = (Dali::Quaternion *)jarg1;
10256   arg2 = (Dali::Quaternion *)jarg2;
10257   if (!arg2) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10259     return 0;
10260   }
10261   {
10262     try {
10263       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10264     } catch (std::out_of_range& e) {
10265       {
10266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10267       };
10268     } catch (std::exception& e) {
10269       {
10270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10271       };
10272     } catch (...) {
10273       {
10274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10275       };
10276     }
10277   }
10278   jresult = (void *)result;
10279   return jresult;
10280 }
10281
10282
10283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10284   void * jresult ;
10285   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10286   Dali::Quaternion *arg2 = 0 ;
10287   Dali::Quaternion *result = 0 ;
10288
10289   arg1 = (Dali::Quaternion *)jarg1;
10290   arg2 = (Dali::Quaternion *)jarg2;
10291   if (!arg2) {
10292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10293     return 0;
10294   }
10295   {
10296     try {
10297       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10298     } catch (std::out_of_range& e) {
10299       {
10300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10301       };
10302     } catch (std::exception& e) {
10303       {
10304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10305       };
10306     } catch (...) {
10307       {
10308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10309       };
10310     }
10311   }
10312   jresult = (void *)result;
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10318   void * jresult ;
10319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10320   float arg2 ;
10321   Dali::Quaternion *result = 0 ;
10322
10323   arg1 = (Dali::Quaternion *)jarg1;
10324   arg2 = (float)jarg2;
10325   {
10326     try {
10327       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10328     } catch (std::out_of_range& e) {
10329       {
10330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (std::exception& e) {
10333       {
10334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342   jresult = (void *)result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10348   void * jresult ;
10349   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10350   float arg2 ;
10351   Dali::Quaternion *result = 0 ;
10352
10353   arg1 = (Dali::Quaternion *)jarg1;
10354   arg2 = (float)jarg2;
10355   {
10356     try {
10357       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10358     } catch (std::out_of_range& e) {
10359       {
10360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (std::exception& e) {
10363       {
10364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10365       };
10366     } catch (...) {
10367       {
10368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10369       };
10370     }
10371   }
10372   jresult = (void *)result;
10373   return jresult;
10374 }
10375
10376
10377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10378   unsigned int jresult ;
10379   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10380   Dali::Quaternion *arg2 = 0 ;
10381   bool result;
10382
10383   arg1 = (Dali::Quaternion *)jarg1;
10384   arg2 = (Dali::Quaternion *)jarg2;
10385   if (!arg2) {
10386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10387     return 0;
10388   }
10389   {
10390     try {
10391       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10392     } catch (std::out_of_range& e) {
10393       {
10394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10395       };
10396     } catch (std::exception& e) {
10397       {
10398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10399       };
10400     } catch (...) {
10401       {
10402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10403       };
10404     }
10405   }
10406   jresult = result;
10407   return jresult;
10408 }
10409
10410
10411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10412   unsigned int jresult ;
10413   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10414   Dali::Quaternion *arg2 = 0 ;
10415   bool result;
10416
10417   arg1 = (Dali::Quaternion *)jarg1;
10418   arg2 = (Dali::Quaternion *)jarg2;
10419   if (!arg2) {
10420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10421     return 0;
10422   }
10423   {
10424     try {
10425       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10426     } catch (std::out_of_range& e) {
10427       {
10428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10429       };
10430     } catch (std::exception& e) {
10431       {
10432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10433       };
10434     } catch (...) {
10435       {
10436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10437       };
10438     }
10439   }
10440   jresult = result;
10441   return jresult;
10442 }
10443
10444
10445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10446   float jresult ;
10447   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10448   float result;
10449
10450   arg1 = (Dali::Quaternion *)jarg1;
10451   {
10452     try {
10453       result = (float)((Dali::Quaternion const *)arg1)->Length();
10454     } catch (std::out_of_range& e) {
10455       {
10456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (std::exception& e) {
10459       {
10460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (...) {
10463       {
10464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10465       };
10466     }
10467   }
10468   jresult = result;
10469   return jresult;
10470 }
10471
10472
10473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10474   float jresult ;
10475   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10476   float result;
10477
10478   arg1 = (Dali::Quaternion *)jarg1;
10479   {
10480     try {
10481       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10482     } catch (std::out_of_range& e) {
10483       {
10484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10485       };
10486     } catch (std::exception& e) {
10487       {
10488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10489       };
10490     } catch (...) {
10491       {
10492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10493       };
10494     }
10495   }
10496   jresult = result;
10497   return jresult;
10498 }
10499
10500
10501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10503
10504   arg1 = (Dali::Quaternion *)jarg1;
10505   {
10506     try {
10507       (arg1)->Normalize();
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10515       };
10516     } catch (...) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10519       };
10520     }
10521   }
10522 }
10523
10524
10525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10526   void * jresult ;
10527   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10528   Dali::Quaternion result;
10529
10530   arg1 = (Dali::Quaternion *)jarg1;
10531   {
10532     try {
10533       result = ((Dali::Quaternion const *)arg1)->Normalized();
10534     } catch (std::out_of_range& e) {
10535       {
10536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10537       };
10538     } catch (std::exception& e) {
10539       {
10540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10541       };
10542     } catch (...) {
10543       {
10544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10545       };
10546     }
10547   }
10548   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10549   return jresult;
10550 }
10551
10552
10553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10554   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10555
10556   arg1 = (Dali::Quaternion *)jarg1;
10557   {
10558     try {
10559       (arg1)->Conjugate();
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10571       };
10572     }
10573   }
10574 }
10575
10576
10577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10578   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10579
10580   arg1 = (Dali::Quaternion *)jarg1;
10581   {
10582     try {
10583       (arg1)->Invert();
10584     } catch (std::out_of_range& e) {
10585       {
10586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10587       };
10588     } catch (std::exception& e) {
10589       {
10590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10591       };
10592     } catch (...) {
10593       {
10594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10595       };
10596     }
10597   }
10598 }
10599
10600
10601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10602   void * jresult ;
10603   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10604   Dali::Quaternion result;
10605
10606   arg1 = (Dali::Quaternion *)jarg1;
10607   {
10608     try {
10609       result = ((Dali::Quaternion const *)arg1)->Log();
10610     } catch (std::out_of_range& e) {
10611       {
10612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (std::exception& e) {
10615       {
10616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10630   void * jresult ;
10631   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10632   Dali::Quaternion result;
10633
10634   arg1 = (Dali::Quaternion *)jarg1;
10635   {
10636     try {
10637       result = ((Dali::Quaternion const *)arg1)->Exp();
10638     } catch (std::out_of_range& e) {
10639       {
10640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (std::exception& e) {
10643       {
10644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (...) {
10647       {
10648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10649       };
10650     }
10651   }
10652   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10653   return jresult;
10654 }
10655
10656
10657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10658   float jresult ;
10659   Dali::Quaternion *arg1 = 0 ;
10660   Dali::Quaternion *arg2 = 0 ;
10661   float result;
10662
10663   arg1 = (Dali::Quaternion *)jarg1;
10664   if (!arg1) {
10665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10666     return 0;
10667   }
10668   arg2 = (Dali::Quaternion *)jarg2;
10669   if (!arg2) {
10670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10671     return 0;
10672   }
10673   {
10674     try {
10675       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10676     } catch (std::out_of_range& e) {
10677       {
10678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10679       };
10680     } catch (std::exception& e) {
10681       {
10682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10683       };
10684     } catch (...) {
10685       {
10686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10687       };
10688     }
10689   }
10690   jresult = result;
10691   return jresult;
10692 }
10693
10694
10695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10696   void * jresult ;
10697   Dali::Quaternion *arg1 = 0 ;
10698   Dali::Quaternion *arg2 = 0 ;
10699   float arg3 ;
10700   Dali::Quaternion result;
10701
10702   arg1 = (Dali::Quaternion *)jarg1;
10703   if (!arg1) {
10704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10705     return 0;
10706   }
10707   arg2 = (Dali::Quaternion *)jarg2;
10708   if (!arg2) {
10709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10710     return 0;
10711   }
10712   arg3 = (float)jarg3;
10713   {
10714     try {
10715       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10716     } catch (std::out_of_range& e) {
10717       {
10718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10719       };
10720     } catch (std::exception& e) {
10721       {
10722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10723       };
10724     } catch (...) {
10725       {
10726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10727       };
10728     }
10729   }
10730   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10731   return jresult;
10732 }
10733
10734
10735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10736   void * jresult ;
10737   Dali::Quaternion *arg1 = 0 ;
10738   Dali::Quaternion *arg2 = 0 ;
10739   float arg3 ;
10740   Dali::Quaternion result;
10741
10742   arg1 = (Dali::Quaternion *)jarg1;
10743   if (!arg1) {
10744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10745     return 0;
10746   }
10747   arg2 = (Dali::Quaternion *)jarg2;
10748   if (!arg2) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10750     return 0;
10751   }
10752   arg3 = (float)jarg3;
10753   {
10754     try {
10755       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10756     } catch (std::out_of_range& e) {
10757       {
10758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10759       };
10760     } catch (std::exception& e) {
10761       {
10762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10763       };
10764     } catch (...) {
10765       {
10766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10767       };
10768     }
10769   }
10770   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10771   return jresult;
10772 }
10773
10774
10775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10776   void * jresult ;
10777   Dali::Quaternion *arg1 = 0 ;
10778   Dali::Quaternion *arg2 = 0 ;
10779   float arg3 ;
10780   Dali::Quaternion result;
10781
10782   arg1 = (Dali::Quaternion *)jarg1;
10783   if (!arg1) {
10784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10785     return 0;
10786   }
10787   arg2 = (Dali::Quaternion *)jarg2;
10788   if (!arg2) {
10789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10790     return 0;
10791   }
10792   arg3 = (float)jarg3;
10793   {
10794     try {
10795       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10796     } catch (std::out_of_range& e) {
10797       {
10798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10799       };
10800     } catch (std::exception& e) {
10801       {
10802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10803       };
10804     } catch (...) {
10805       {
10806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10807       };
10808     }
10809   }
10810   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10811   return jresult;
10812 }
10813
10814
10815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10816   void * jresult ;
10817   Dali::Quaternion *arg1 = 0 ;
10818   Dali::Quaternion *arg2 = 0 ;
10819   Dali::Quaternion *arg3 = 0 ;
10820   Dali::Quaternion *arg4 = 0 ;
10821   float arg5 ;
10822   Dali::Quaternion result;
10823
10824   arg1 = (Dali::Quaternion *)jarg1;
10825   if (!arg1) {
10826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10827     return 0;
10828   }
10829   arg2 = (Dali::Quaternion *)jarg2;
10830   if (!arg2) {
10831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10832     return 0;
10833   }
10834   arg3 = (Dali::Quaternion *)jarg3;
10835   if (!arg3) {
10836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10837     return 0;
10838   }
10839   arg4 = (Dali::Quaternion *)jarg4;
10840   if (!arg4) {
10841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10842     return 0;
10843   }
10844   arg5 = (float)jarg5;
10845   {
10846     try {
10847       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10848     } catch (std::out_of_range& e) {
10849       {
10850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10851       };
10852     } catch (std::exception& e) {
10853       {
10854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (...) {
10857       {
10858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10859       };
10860     }
10861   }
10862   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10863   return jresult;
10864 }
10865
10866
10867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10868   float jresult ;
10869   Dali::Quaternion *arg1 = 0 ;
10870   Dali::Quaternion *arg2 = 0 ;
10871   float result;
10872
10873   arg1 = (Dali::Quaternion *)jarg1;
10874   if (!arg1) {
10875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10876     return 0;
10877   }
10878   arg2 = (Dali::Quaternion *)jarg2;
10879   if (!arg2) {
10880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10881     return 0;
10882   }
10883   {
10884     try {
10885       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10886     } catch (std::out_of_range& e) {
10887       {
10888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10889       };
10890     } catch (std::exception& e) {
10891       {
10892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (...) {
10895       {
10896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10897       };
10898     }
10899   }
10900   jresult = result;
10901   return jresult;
10902 }
10903
10904
10905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10906   void * jresult ;
10907   Dali::Matrix *result = 0 ;
10908
10909   {
10910     try {
10911       result = (Dali::Matrix *)new Dali::Matrix();
10912     } catch (std::out_of_range& e) {
10913       {
10914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (std::exception& e) {
10917       {
10918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10923       };
10924     }
10925   }
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10932   void * jresult ;
10933   bool arg1 ;
10934   Dali::Matrix *result = 0 ;
10935
10936   arg1 = jarg1 ? true : false;
10937   {
10938     try {
10939       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10940     } catch (std::out_of_range& e) {
10941       {
10942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10943       };
10944     } catch (std::exception& e) {
10945       {
10946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (...) {
10949       {
10950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10951       };
10952     }
10953   }
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10960   void * jresult ;
10961   float *arg1 = (float *) 0 ;
10962   Dali::Matrix *result = 0 ;
10963
10964   arg1 = jarg1;
10965   {
10966     try {
10967       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
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
10984
10985   return jresult;
10986 }
10987
10988
10989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10990   void * jresult ;
10991   Dali::Quaternion *arg1 = 0 ;
10992   Dali::Matrix *result = 0 ;
10993
10994   arg1 = (Dali::Quaternion *)jarg1;
10995   if (!arg1) {
10996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10997     return 0;
10998   }
10999   {
11000     try {
11001       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11002     } catch (std::out_of_range& e) {
11003       {
11004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11005       };
11006     } catch (std::exception& e) {
11007       {
11008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11009       };
11010     } catch (...) {
11011       {
11012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11013       };
11014     }
11015   }
11016   jresult = (void *)result;
11017   return jresult;
11018 }
11019
11020
11021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11022   void * jresult ;
11023   Dali::Matrix *arg1 = 0 ;
11024   Dali::Matrix *result = 0 ;
11025
11026   arg1 = (Dali::Matrix *)jarg1;
11027   if (!arg1) {
11028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11029     return 0;
11030   }
11031   {
11032     try {
11033       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11034     } catch (std::out_of_range& e) {
11035       {
11036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11037       };
11038     } catch (std::exception& e) {
11039       {
11040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11041       };
11042     } catch (...) {
11043       {
11044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11045       };
11046     }
11047   }
11048   jresult = (void *)result;
11049   return jresult;
11050 }
11051
11052
11053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11054   void * jresult ;
11055   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11056   Dali::Matrix *arg2 = 0 ;
11057   Dali::Matrix *result = 0 ;
11058
11059   arg1 = (Dali::Matrix *)jarg1;
11060   arg2 = (Dali::Matrix *)jarg2;
11061   if (!arg2) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11068     } catch (std::out_of_range& e) {
11069       {
11070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11071       };
11072     } catch (std::exception& e) {
11073       {
11074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11075       };
11076     } catch (...) {
11077       {
11078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11079       };
11080     }
11081   }
11082   jresult = (void *)result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11088   void * jresult ;
11089   Dali::Matrix *result = 0 ;
11090
11091   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11092   jresult = (void *)result;
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11099
11100   arg1 = (Dali::Matrix *)jarg1;
11101   {
11102     try {
11103       (arg1)->SetIdentity();
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11111       };
11112     } catch (...) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11115       };
11116     }
11117   }
11118 }
11119
11120
11121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11122   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11123   Dali::Vector3 *arg2 = 0 ;
11124
11125   arg1 = (Dali::Matrix *)jarg1;
11126   arg2 = (Dali::Vector3 *)jarg2;
11127   if (!arg2) {
11128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11129     return ;
11130   }
11131   {
11132     try {
11133       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11134     } catch (std::out_of_range& e) {
11135       {
11136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11137       };
11138     } catch (std::exception& e) {
11139       {
11140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11145       };
11146     }
11147   }
11148 }
11149
11150
11151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11152   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11153   Dali::Matrix *arg2 = 0 ;
11154
11155   arg1 = (Dali::Matrix *)jarg1;
11156   arg2 = (Dali::Matrix *)jarg2;
11157   if (!arg2) {
11158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11159     return ;
11160   }
11161   {
11162     try {
11163       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11164     } catch (std::out_of_range& e) {
11165       {
11166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11167       };
11168     } catch (std::exception& e) {
11169       {
11170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11171       };
11172     } catch (...) {
11173       {
11174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11175       };
11176     }
11177   }
11178 }
11179
11180
11181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11182   unsigned int jresult ;
11183   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11184   bool result;
11185
11186   arg1 = (Dali::Matrix *)jarg1;
11187   {
11188     try {
11189       result = (bool)(arg1)->Invert();
11190     } catch (std::out_of_range& e) {
11191       {
11192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11193       };
11194     } catch (std::exception& e) {
11195       {
11196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11197       };
11198     } catch (...) {
11199       {
11200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11201       };
11202     }
11203   }
11204   jresult = result;
11205   return jresult;
11206 }
11207
11208
11209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11210   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11211
11212   arg1 = (Dali::Matrix *)jarg1;
11213   {
11214     try {
11215       (arg1)->Transpose();
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11223       };
11224     } catch (...) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11227       };
11228     }
11229   }
11230 }
11231
11232
11233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11234   void * jresult ;
11235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11236   Dali::Vector3 result;
11237
11238   arg1 = (Dali::Matrix *)jarg1;
11239   {
11240     try {
11241       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11242     } catch (std::out_of_range& e) {
11243       {
11244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11245       };
11246     } catch (std::exception& e) {
11247       {
11248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (...) {
11251       {
11252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11253       };
11254     }
11255   }
11256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11257   return jresult;
11258 }
11259
11260
11261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11262   void * jresult ;
11263   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11264   Dali::Vector3 result;
11265
11266   arg1 = (Dali::Matrix *)jarg1;
11267   {
11268     try {
11269       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11270     } catch (std::out_of_range& e) {
11271       {
11272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11273       };
11274     } catch (std::exception& e) {
11275       {
11276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11277       };
11278     } catch (...) {
11279       {
11280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11281       };
11282     }
11283   }
11284   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11290   void * jresult ;
11291   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11292   Dali::Vector3 result;
11293
11294   arg1 = (Dali::Matrix *)jarg1;
11295   {
11296     try {
11297       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11298     } catch (std::out_of_range& e) {
11299       {
11300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (std::exception& e) {
11303       {
11304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11305       };
11306     } catch (...) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11309       };
11310     }
11311   }
11312   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11318   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11319   Dali::Vector3 *arg2 = 0 ;
11320
11321   arg1 = (Dali::Matrix *)jarg1;
11322   arg2 = (Dali::Vector3 *)jarg2;
11323   if (!arg2) {
11324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11325     return ;
11326   }
11327   {
11328     try {
11329       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11337       };
11338     } catch (...) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11341       };
11342     }
11343   }
11344 }
11345
11346
11347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11348   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11349   Dali::Vector3 *arg2 = 0 ;
11350
11351   arg1 = (Dali::Matrix *)jarg1;
11352   arg2 = (Dali::Vector3 *)jarg2;
11353   if (!arg2) {
11354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11355     return ;
11356   }
11357   {
11358     try {
11359       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11367       };
11368     } catch (...) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11371       };
11372     }
11373   }
11374 }
11375
11376
11377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11378   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11379   Dali::Vector3 *arg2 = 0 ;
11380
11381   arg1 = (Dali::Matrix *)jarg1;
11382   arg2 = (Dali::Vector3 *)jarg2;
11383   if (!arg2) {
11384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11385     return ;
11386   }
11387   {
11388     try {
11389       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11390     } catch (std::out_of_range& e) {
11391       {
11392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11393       };
11394     } catch (std::exception& e) {
11395       {
11396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11397       };
11398     } catch (...) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11401       };
11402     }
11403   }
11404 }
11405
11406
11407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11408   void * jresult ;
11409   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11410   Dali::Vector4 *result = 0 ;
11411
11412   arg1 = (Dali::Matrix *)jarg1;
11413   {
11414     try {
11415       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11416     } catch (std::out_of_range& e) {
11417       {
11418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11419       };
11420     } catch (std::exception& e) {
11421       {
11422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11423       };
11424     } catch (...) {
11425       {
11426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11427       };
11428     }
11429   }
11430   jresult = (void *)result;
11431   return jresult;
11432 }
11433
11434
11435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11436   void * jresult ;
11437   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11438   Dali::Vector3 *result = 0 ;
11439
11440   arg1 = (Dali::Matrix *)jarg1;
11441   {
11442     try {
11443       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11444     } catch (std::out_of_range& e) {
11445       {
11446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (std::exception& e) {
11449       {
11450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11451       };
11452     } catch (...) {
11453       {
11454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11455       };
11456     }
11457   }
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11464   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11465   Dali::Vector4 *arg2 = 0 ;
11466
11467   arg1 = (Dali::Matrix *)jarg1;
11468   arg2 = (Dali::Vector4 *)jarg2;
11469   if (!arg2) {
11470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11471     return ;
11472   }
11473   {
11474     try {
11475       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11476     } catch (std::out_of_range& e) {
11477       {
11478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11479       };
11480     } catch (std::exception& e) {
11481       {
11482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11483       };
11484     } catch (...) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11487       };
11488     }
11489   }
11490 }
11491
11492
11493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11494   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11495   Dali::Vector3 *arg2 = 0 ;
11496
11497   arg1 = (Dali::Matrix *)jarg1;
11498   arg2 = (Dali::Vector3 *)jarg2;
11499   if (!arg2) {
11500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11501     return ;
11502   }
11503   {
11504     try {
11505       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11506     } catch (std::out_of_range& e) {
11507       {
11508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11509       };
11510     } catch (std::exception& e) {
11511       {
11512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11517       };
11518     }
11519   }
11520 }
11521
11522
11523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11524   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11525
11526   arg1 = (Dali::Matrix *)jarg1;
11527   {
11528     try {
11529       (arg1)->OrthoNormalize();
11530     } catch (std::out_of_range& e) {
11531       {
11532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11533       };
11534     } catch (std::exception& e) {
11535       {
11536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11537       };
11538     } catch (...) {
11539       {
11540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11541       };
11542     }
11543   }
11544 }
11545
11546
11547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11548   void * jresult ;
11549   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11550   float *result = 0 ;
11551
11552   arg1 = (Dali::Matrix *)jarg1;
11553   {
11554     try {
11555       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11563       };
11564     } catch (...) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11567       };
11568     }
11569   }
11570   jresult = (void *)result;
11571   return jresult;
11572 }
11573
11574
11575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11576   Dali::Matrix *arg1 = 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   Dali::Matrix *arg3 = 0 ;
11579
11580   arg1 = (Dali::Matrix *)jarg1;
11581   if (!arg1) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11583     return ;
11584   }
11585   arg2 = (Dali::Matrix *)jarg2;
11586   if (!arg2) {
11587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11588     return ;
11589   }
11590   arg3 = (Dali::Matrix *)jarg3;
11591   if (!arg3) {
11592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11593     return ;
11594   }
11595   {
11596     try {
11597       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11598     } catch (std::out_of_range& e) {
11599       {
11600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11601       };
11602     } catch (std::exception& e) {
11603       {
11604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11605       };
11606     } catch (...) {
11607       {
11608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11609       };
11610     }
11611   }
11612 }
11613
11614
11615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11616   Dali::Matrix *arg1 = 0 ;
11617   Dali::Matrix *arg2 = 0 ;
11618   Dali::Quaternion *arg3 = 0 ;
11619
11620   arg1 = (Dali::Matrix *)jarg1;
11621   if (!arg1) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11623     return ;
11624   }
11625   arg2 = (Dali::Matrix *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11628     return ;
11629   }
11630   arg3 = (Dali::Quaternion *)jarg3;
11631   if (!arg3) {
11632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11633     return ;
11634   }
11635   {
11636     try {
11637       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11638     } catch (std::out_of_range& e) {
11639       {
11640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11641       };
11642     } catch (std::exception& e) {
11643       {
11644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11645       };
11646     } catch (...) {
11647       {
11648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11649       };
11650     }
11651   }
11652 }
11653
11654
11655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11656   void * jresult ;
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector4 *arg2 = 0 ;
11659   Dali::Vector4 result;
11660
11661   arg1 = (Dali::Matrix *)jarg1;
11662   arg2 = (Dali::Vector4 *)jarg2;
11663   if (!arg2) {
11664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11665     return 0;
11666   }
11667   {
11668     try {
11669       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11670     } catch (std::out_of_range& e) {
11671       {
11672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (std::exception& e) {
11675       {
11676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11677       };
11678     } catch (...) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11681       };
11682     }
11683   }
11684   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11685   return jresult;
11686 }
11687
11688
11689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11690   unsigned int jresult ;
11691   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11692   Dali::Matrix *arg2 = 0 ;
11693   bool result;
11694
11695   arg1 = (Dali::Matrix *)jarg1;
11696   arg2 = (Dali::Matrix *)jarg2;
11697   if (!arg2) {
11698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11699     return 0;
11700   }
11701   {
11702     try {
11703       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11704     } catch (std::out_of_range& e) {
11705       {
11706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11707       };
11708     } catch (std::exception& e) {
11709       {
11710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11711       };
11712     } catch (...) {
11713       {
11714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11715       };
11716     }
11717   }
11718   jresult = result;
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11724   unsigned int jresult ;
11725   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11726   Dali::Matrix *arg2 = 0 ;
11727   bool result;
11728
11729   arg1 = (Dali::Matrix *)jarg1;
11730   arg2 = (Dali::Matrix *)jarg2;
11731   if (!arg2) {
11732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11733     return 0;
11734   }
11735   {
11736     try {
11737       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11745       };
11746     } catch (...) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11749       };
11750     }
11751   }
11752   jresult = result;
11753   return jresult;
11754 }
11755
11756
11757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11759   Dali::Vector3 *arg2 = 0 ;
11760   Dali::Quaternion *arg3 = 0 ;
11761   Dali::Vector3 *arg4 = 0 ;
11762
11763   arg1 = (Dali::Matrix *)jarg1;
11764   arg2 = (Dali::Vector3 *)jarg2;
11765   if (!arg2) {
11766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11767     return ;
11768   }
11769   arg3 = (Dali::Quaternion *)jarg3;
11770   if (!arg3) {
11771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11772     return ;
11773   }
11774   arg4 = (Dali::Vector3 *)jarg4;
11775   if (!arg4) {
11776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11777     return ;
11778   }
11779   {
11780     try {
11781       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11782     } catch (std::out_of_range& e) {
11783       {
11784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11785       };
11786     } catch (std::exception& e) {
11787       {
11788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (...) {
11791       {
11792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11793       };
11794     }
11795   }
11796 }
11797
11798
11799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11800   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11801   Dali::Vector3 *arg2 = 0 ;
11802   Dali::Quaternion *arg3 = 0 ;
11803   Dali::Vector3 *arg4 = 0 ;
11804
11805   arg1 = (Dali::Matrix *)jarg1;
11806   arg2 = (Dali::Vector3 *)jarg2;
11807   if (!arg2) {
11808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11809     return ;
11810   }
11811   arg3 = (Dali::Quaternion *)jarg3;
11812   if (!arg3) {
11813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11814     return ;
11815   }
11816   arg4 = (Dali::Vector3 *)jarg4;
11817   if (!arg4) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11819     return ;
11820   }
11821   {
11822     try {
11823       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11824     } catch (std::out_of_range& e) {
11825       {
11826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11827       };
11828     } catch (std::exception& e) {
11829       {
11830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11831       };
11832     } catch (...) {
11833       {
11834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11835       };
11836     }
11837   }
11838 }
11839
11840
11841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11842   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11843   Dali::Vector3 *arg2 = 0 ;
11844   Dali::Vector3 *arg3 = 0 ;
11845   Dali::Vector3 *arg4 = 0 ;
11846   Dali::Vector3 *arg5 = 0 ;
11847
11848   arg1 = (Dali::Matrix *)jarg1;
11849   arg2 = (Dali::Vector3 *)jarg2;
11850   if (!arg2) {
11851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11852     return ;
11853   }
11854   arg3 = (Dali::Vector3 *)jarg3;
11855   if (!arg3) {
11856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11857     return ;
11858   }
11859   arg4 = (Dali::Vector3 *)jarg4;
11860   if (!arg4) {
11861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11862     return ;
11863   }
11864   arg5 = (Dali::Vector3 *)jarg5;
11865   if (!arg5) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11867     return ;
11868   }
11869   {
11870     try {
11871       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11879       };
11880     } catch (...) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11883       };
11884     }
11885   }
11886 }
11887
11888
11889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11890   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11891   Dali::Vector3 *arg2 = 0 ;
11892   Dali::Quaternion *arg3 = 0 ;
11893   Dali::Vector3 *arg4 = 0 ;
11894
11895   arg1 = (Dali::Matrix *)jarg1;
11896   arg2 = (Dali::Vector3 *)jarg2;
11897   if (!arg2) {
11898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11899     return ;
11900   }
11901   arg3 = (Dali::Quaternion *)jarg3;
11902   if (!arg3) {
11903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11904     return ;
11905   }
11906   arg4 = (Dali::Vector3 *)jarg4;
11907   if (!arg4) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11909     return ;
11910   }
11911   {
11912     try {
11913       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11914     } catch (std::out_of_range& e) {
11915       {
11916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11917       };
11918     } catch (std::exception& e) {
11919       {
11920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11925       };
11926     }
11927   }
11928 }
11929
11930
11931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11932   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11933
11934   arg1 = (Dali::Matrix *)jarg1;
11935   {
11936     try {
11937       delete arg1;
11938     } catch (std::out_of_range& e) {
11939       {
11940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11941       };
11942     } catch (std::exception& e) {
11943       {
11944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11945       };
11946     } catch (...) {
11947       {
11948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11949       };
11950     }
11951   }
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11956   void * jresult ;
11957   Dali::Matrix3 *result = 0 ;
11958
11959   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11960   jresult = (void *)result;
11961   return jresult;
11962 }
11963
11964
11965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11966   void * jresult ;
11967   Dali::Matrix3 *result = 0 ;
11968
11969   {
11970     try {
11971       result = (Dali::Matrix3 *)new Dali::Matrix3();
11972     } catch (std::out_of_range& e) {
11973       {
11974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (std::exception& e) {
11977       {
11978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986   jresult = (void *)result;
11987   return jresult;
11988 }
11989
11990
11991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11992   void * jresult ;
11993   Dali::Matrix3 *arg1 = 0 ;
11994   Dali::Matrix3 *result = 0 ;
11995
11996   arg1 = (Dali::Matrix3 *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11999     return 0;
12000   }
12001   {
12002     try {
12003       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12004     } catch (std::out_of_range& e) {
12005       {
12006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12007       };
12008     } catch (std::exception& e) {
12009       {
12010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12011       };
12012     } catch (...) {
12013       {
12014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12015       };
12016     }
12017   }
12018   jresult = (void *)result;
12019   return jresult;
12020 }
12021
12022
12023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12024   void * jresult ;
12025   Dali::Matrix *arg1 = 0 ;
12026   Dali::Matrix3 *result = 0 ;
12027
12028   arg1 = (Dali::Matrix *)jarg1;
12029   if (!arg1) {
12030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12031     return 0;
12032   }
12033   {
12034     try {
12035       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12036     } catch (std::out_of_range& e) {
12037       {
12038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12039       };
12040     } catch (std::exception& e) {
12041       {
12042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12043       };
12044     } catch (...) {
12045       {
12046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12047       };
12048     }
12049   }
12050   jresult = (void *)result;
12051   return jresult;
12052 }
12053
12054
12055 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) {
12056   void * jresult ;
12057   float arg1 ;
12058   float arg2 ;
12059   float arg3 ;
12060   float arg4 ;
12061   float arg5 ;
12062   float arg6 ;
12063   float arg7 ;
12064   float arg8 ;
12065   float arg9 ;
12066   Dali::Matrix3 *result = 0 ;
12067
12068   arg1 = (float)jarg1;
12069   arg2 = (float)jarg2;
12070   arg3 = (float)jarg3;
12071   arg4 = (float)jarg4;
12072   arg5 = (float)jarg5;
12073   arg6 = (float)jarg6;
12074   arg7 = (float)jarg7;
12075   arg8 = (float)jarg8;
12076   arg9 = (float)jarg9;
12077   {
12078     try {
12079       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12080     } catch (std::out_of_range& e) {
12081       {
12082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (std::exception& e) {
12085       {
12086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12087       };
12088     } catch (...) {
12089       {
12090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12091       };
12092     }
12093   }
12094   jresult = (void *)result;
12095   return jresult;
12096 }
12097
12098
12099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12100   void * jresult ;
12101   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12102   Dali::Matrix3 *arg2 = 0 ;
12103   Dali::Matrix3 *result = 0 ;
12104
12105   arg1 = (Dali::Matrix3 *)jarg1;
12106   arg2 = (Dali::Matrix3 *)jarg2;
12107   if (!arg2) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12109     return 0;
12110   }
12111   {
12112     try {
12113       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128   jresult = (void *)result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12134   void * jresult ;
12135   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12136   Dali::Matrix *arg2 = 0 ;
12137   Dali::Matrix3 *result = 0 ;
12138
12139   arg1 = (Dali::Matrix3 *)jarg1;
12140   arg2 = (Dali::Matrix *)jarg2;
12141   if (!arg2) {
12142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12143     return 0;
12144   }
12145   {
12146     try {
12147       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12148     } catch (std::out_of_range& e) {
12149       {
12150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12151       };
12152     } catch (std::exception& e) {
12153       {
12154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12155       };
12156     } catch (...) {
12157       {
12158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12159       };
12160     }
12161   }
12162   jresult = (void *)result;
12163   return jresult;
12164 }
12165
12166
12167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12168   unsigned int jresult ;
12169   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12170   Dali::Matrix3 *arg2 = 0 ;
12171   bool result;
12172
12173   arg1 = (Dali::Matrix3 *)jarg1;
12174   arg2 = (Dali::Matrix3 *)jarg2;
12175   if (!arg2) {
12176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12177     return 0;
12178   }
12179   {
12180     try {
12181       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12182     } catch (std::out_of_range& e) {
12183       {
12184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12185       };
12186     } catch (std::exception& e) {
12187       {
12188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (...) {
12191       {
12192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12193       };
12194     }
12195   }
12196   jresult = result;
12197   return jresult;
12198 }
12199
12200
12201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12202   unsigned int jresult ;
12203   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12204   Dali::Matrix3 *arg2 = 0 ;
12205   bool result;
12206
12207   arg1 = (Dali::Matrix3 *)jarg1;
12208   arg2 = (Dali::Matrix3 *)jarg2;
12209   if (!arg2) {
12210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12211     return 0;
12212   }
12213   {
12214     try {
12215       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12216     } catch (std::out_of_range& e) {
12217       {
12218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12219       };
12220     } catch (std::exception& e) {
12221       {
12222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (...) {
12225       {
12226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12227       };
12228     }
12229   }
12230   jresult = result;
12231   return jresult;
12232 }
12233
12234
12235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12236   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12237
12238   arg1 = (Dali::Matrix3 *)jarg1;
12239   {
12240     try {
12241       delete arg1;
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (...) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12253       };
12254     }
12255   }
12256 }
12257
12258
12259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12260   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12261
12262   arg1 = (Dali::Matrix3 *)jarg1;
12263   {
12264     try {
12265       (arg1)->SetIdentity();
12266     } catch (std::out_of_range& e) {
12267       {
12268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12269       };
12270     } catch (std::exception& e) {
12271       {
12272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12273       };
12274     } catch (...) {
12275       {
12276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12277       };
12278     }
12279   }
12280 }
12281
12282
12283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12284   void * jresult ;
12285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12286   float *result = 0 ;
12287
12288   arg1 = (Dali::Matrix3 *)jarg1;
12289   {
12290     try {
12291       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (...) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12303       };
12304     }
12305   }
12306   jresult = (void *)result;
12307   return jresult;
12308 }
12309
12310
12311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12312   unsigned int jresult ;
12313   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12314   bool result;
12315
12316   arg1 = (Dali::Matrix3 *)jarg1;
12317   {
12318     try {
12319       result = (bool)(arg1)->Invert();
12320     } catch (std::out_of_range& e) {
12321       {
12322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12323       };
12324     } catch (std::exception& e) {
12325       {
12326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (...) {
12329       {
12330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12331       };
12332     }
12333   }
12334   jresult = result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12340   unsigned int jresult ;
12341   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12342   bool result;
12343
12344   arg1 = (Dali::Matrix3 *)jarg1;
12345   {
12346     try {
12347       result = (bool)(arg1)->Transpose();
12348     } catch (std::out_of_range& e) {
12349       {
12350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12351       };
12352     } catch (std::exception& e) {
12353       {
12354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12355       };
12356     } catch (...) {
12357       {
12358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12359       };
12360     }
12361   }
12362   jresult = result;
12363   return jresult;
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12368   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12369   float arg2 ;
12370
12371   arg1 = (Dali::Matrix3 *)jarg1;
12372   arg2 = (float)jarg2;
12373   {
12374     try {
12375       (arg1)->Scale(arg2);
12376     } catch (std::out_of_range& e) {
12377       {
12378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12379       };
12380     } catch (std::exception& e) {
12381       {
12382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12383       };
12384     } catch (...) {
12385       {
12386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12387       };
12388     }
12389   }
12390 }
12391
12392
12393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12394   float jresult ;
12395   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12396   float result;
12397
12398   arg1 = (Dali::Matrix3 *)jarg1;
12399   {
12400     try {
12401       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12402     } catch (std::out_of_range& e) {
12403       {
12404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12405       };
12406     } catch (std::exception& e) {
12407       {
12408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12413       };
12414     }
12415   }
12416   jresult = result;
12417   return jresult;
12418 }
12419
12420
12421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12422   unsigned int jresult ;
12423   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12424   bool result;
12425
12426   arg1 = (Dali::Matrix3 *)jarg1;
12427   {
12428     try {
12429       result = (bool)(arg1)->ScaledInverseTranspose();
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12437       };
12438     } catch (...) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12441       };
12442     }
12443   }
12444   jresult = result;
12445   return jresult;
12446 }
12447
12448
12449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12450   Dali::Matrix3 *arg1 = 0 ;
12451   Dali::Matrix3 *arg2 = 0 ;
12452   Dali::Matrix3 *arg3 = 0 ;
12453
12454   arg1 = (Dali::Matrix3 *)jarg1;
12455   if (!arg1) {
12456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12457     return ;
12458   }
12459   arg2 = (Dali::Matrix3 *)jarg2;
12460   if (!arg2) {
12461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12462     return ;
12463   }
12464   arg3 = (Dali::Matrix3 *)jarg3;
12465   if (!arg3) {
12466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12467     return ;
12468   }
12469   {
12470     try {
12471       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12472     } catch (std::out_of_range& e) {
12473       {
12474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12475       };
12476     } catch (std::exception& e) {
12477       {
12478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12483       };
12484     }
12485   }
12486 }
12487
12488
12489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12490   float jresult ;
12491   float arg1 ;
12492   float arg2 ;
12493   float result;
12494
12495   arg1 = (float)jarg1;
12496   arg2 = (float)jarg2;
12497   {
12498     try {
12499       result = (float)Dali::Random::Range(arg1,arg2);
12500     } catch (std::out_of_range& e) {
12501       {
12502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (std::exception& e) {
12505       {
12506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12511       };
12512     }
12513   }
12514   jresult = result;
12515   return jresult;
12516 }
12517
12518
12519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12520   void * jresult ;
12521   Dali::Vector4 result;
12522
12523   {
12524     try {
12525       result = Dali::Random::Axis();
12526     } catch (std::out_of_range& e) {
12527       {
12528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12529       };
12530     } catch (std::exception& e) {
12531       {
12532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12533       };
12534     } catch (...) {
12535       {
12536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12537       };
12538     }
12539   }
12540   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12541   return jresult;
12542 }
12543
12544
12545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12546   void * jresult ;
12547   Dali::AngleAxis *result = 0 ;
12548
12549   {
12550     try {
12551       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12552     } catch (std::out_of_range& e) {
12553       {
12554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12555       };
12556     } catch (std::exception& e) {
12557       {
12558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12563       };
12564     }
12565   }
12566   jresult = (void *)result;
12567   return jresult;
12568 }
12569
12570
12571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12572   void * jresult ;
12573   Dali::Radian arg1 ;
12574   Dali::Vector3 *arg2 = 0 ;
12575   Dali::Radian *argp1 ;
12576   Dali::AngleAxis *result = 0 ;
12577
12578   argp1 = (Dali::Radian *)jarg1;
12579   if (!argp1) {
12580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12581     return 0;
12582   }
12583   arg1 = *argp1;
12584   arg2 = (Dali::Vector3 *)jarg2;
12585   if (!arg2) {
12586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12587     return 0;
12588   }
12589   {
12590     try {
12591       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12592     } catch (std::out_of_range& e) {
12593       {
12594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12595       };
12596     } catch (std::exception& e) {
12597       {
12598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12599       };
12600     } catch (...) {
12601       {
12602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12603       };
12604     }
12605   }
12606   jresult = (void *)result;
12607   return jresult;
12608 }
12609
12610
12611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12612   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12613   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12614
12615   arg1 = (Dali::AngleAxis *)jarg1;
12616   arg2 = (Dali::Radian *)jarg2;
12617   if (arg1) (arg1)->angle = *arg2;
12618 }
12619
12620
12621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12622   void * jresult ;
12623   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12624   Dali::Radian *result = 0 ;
12625
12626   arg1 = (Dali::AngleAxis *)jarg1;
12627   result = (Dali::Radian *)& ((arg1)->angle);
12628   jresult = (void *)result;
12629   return jresult;
12630 }
12631
12632
12633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12634   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12635   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12636
12637   arg1 = (Dali::AngleAxis *)jarg1;
12638   arg2 = (Dali::Vector3 *)jarg2;
12639   if (arg1) (arg1)->axis = *arg2;
12640 }
12641
12642
12643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12644   void * jresult ;
12645   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12646   Dali::Vector3 *result = 0 ;
12647
12648   arg1 = (Dali::AngleAxis *)jarg1;
12649   result = (Dali::Vector3 *)& ((arg1)->axis);
12650   jresult = (void *)result;
12651   return jresult;
12652 }
12653
12654
12655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12656   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12657
12658   arg1 = (Dali::AngleAxis *)jarg1;
12659   {
12660     try {
12661       delete arg1;
12662     } catch (std::out_of_range& e) {
12663       {
12664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12665       };
12666     } catch (std::exception& e) {
12667       {
12668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12669       };
12670     } catch (...) {
12671       {
12672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12673       };
12674     }
12675   }
12676 }
12677
12678
12679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12680   unsigned int jresult ;
12681   Dali::AngleAxis *arg1 = 0 ;
12682   Dali::AngleAxis *arg2 = 0 ;
12683   bool result;
12684
12685   arg1 = (Dali::AngleAxis *)jarg1;
12686   if (!arg1) {
12687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12688     return 0;
12689   }
12690   arg2 = (Dali::AngleAxis *)jarg2;
12691   if (!arg2) {
12692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12693     return 0;
12694   }
12695   {
12696     try {
12697       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12698     } catch (std::out_of_range& e) {
12699       {
12700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12701       };
12702     } catch (std::exception& e) {
12703       {
12704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12705       };
12706     } catch (...) {
12707       {
12708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12709       };
12710     }
12711   }
12712   jresult = result;
12713   return jresult;
12714 }
12715
12716
12717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12718   unsigned int jresult ;
12719   unsigned int arg1 ;
12720   unsigned int result;
12721
12722   arg1 = (unsigned int)jarg1;
12723   {
12724     try {
12725       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12726     } catch (std::out_of_range& e) {
12727       {
12728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12729       };
12730     } catch (std::exception& e) {
12731       {
12732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (...) {
12735       {
12736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12737       };
12738     }
12739   }
12740   jresult = result;
12741   return jresult;
12742 }
12743
12744
12745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12746   unsigned int jresult ;
12747   unsigned int arg1 ;
12748   bool result;
12749
12750   arg1 = (unsigned int)jarg1;
12751   {
12752     try {
12753       result = (bool)Dali::IsPowerOfTwo(arg1);
12754     } catch (std::out_of_range& e) {
12755       {
12756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12757       };
12758     } catch (std::exception& e) {
12759       {
12760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12761       };
12762     } catch (...) {
12763       {
12764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12765       };
12766     }
12767   }
12768   jresult = result;
12769   return jresult;
12770 }
12771
12772
12773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12774   float jresult ;
12775   float arg1 ;
12776   float arg2 ;
12777   float result;
12778
12779   arg1 = (float)jarg1;
12780   arg2 = (float)jarg2;
12781   {
12782     try {
12783       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12784     } catch (std::out_of_range& e) {
12785       {
12786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12787       };
12788     } catch (std::exception& e) {
12789       {
12790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12791       };
12792     } catch (...) {
12793       {
12794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12795       };
12796     }
12797   }
12798   jresult = result;
12799   return jresult;
12800 }
12801
12802
12803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12804   unsigned int jresult ;
12805   float arg1 ;
12806   bool result;
12807
12808   arg1 = (float)jarg1;
12809   {
12810     try {
12811       result = (bool)Dali::EqualsZero(arg1);
12812     } catch (std::out_of_range& e) {
12813       {
12814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (std::exception& e) {
12817       {
12818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826   jresult = result;
12827   return jresult;
12828 }
12829
12830
12831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12832   unsigned int jresult ;
12833   float arg1 ;
12834   float arg2 ;
12835   bool result;
12836
12837   arg1 = (float)jarg1;
12838   arg2 = (float)jarg2;
12839   {
12840     try {
12841       result = (bool)Dali::Equals(arg1,arg2);
12842     } catch (std::out_of_range& e) {
12843       {
12844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12845       };
12846     } catch (std::exception& e) {
12847       {
12848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12849       };
12850     } catch (...) {
12851       {
12852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12853       };
12854     }
12855   }
12856   jresult = result;
12857   return jresult;
12858 }
12859
12860
12861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12862   unsigned int jresult ;
12863   float arg1 ;
12864   float arg2 ;
12865   float arg3 ;
12866   bool result;
12867
12868   arg1 = (float)jarg1;
12869   arg2 = (float)jarg2;
12870   arg3 = (float)jarg3;
12871   {
12872     try {
12873       result = (bool)Dali::Equals(arg1,arg2,arg3);
12874     } catch (std::out_of_range& e) {
12875       {
12876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12877       };
12878     } catch (std::exception& e) {
12879       {
12880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12881       };
12882     } catch (...) {
12883       {
12884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12885       };
12886     }
12887   }
12888   jresult = result;
12889   return jresult;
12890 }
12891
12892
12893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12894   float jresult ;
12895   float arg1 ;
12896   int arg2 ;
12897   float result;
12898
12899   arg1 = (float)jarg1;
12900   arg2 = (int)jarg2;
12901   {
12902     try {
12903       result = (float)Dali::Round(arg1,arg2);
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12911       };
12912     } catch (...) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12915       };
12916     }
12917   }
12918   jresult = result;
12919   return jresult;
12920 }
12921
12922
12923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12924   float jresult ;
12925   float arg1 ;
12926   float arg2 ;
12927   float arg3 ;
12928   float result;
12929
12930   arg1 = (float)jarg1;
12931   arg2 = (float)jarg2;
12932   arg3 = (float)jarg3;
12933   {
12934     try {
12935       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12936     } catch (std::out_of_range& e) {
12937       {
12938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (std::exception& e) {
12941       {
12942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (...) {
12945       {
12946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12947       };
12948     }
12949   }
12950   jresult = result;
12951   return jresult;
12952 }
12953
12954
12955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12956   float jresult ;
12957   float arg1 ;
12958   float arg2 ;
12959   float arg3 ;
12960   float arg4 ;
12961   float result;
12962
12963   arg1 = (float)jarg1;
12964   arg2 = (float)jarg2;
12965   arg3 = (float)jarg3;
12966   arg4 = (float)jarg4;
12967   {
12968     try {
12969       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
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 = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12990   int jresult ;
12991   int result;
12992
12993   result = (int)(int)Dali::Property::INVALID_INDEX;
12994   jresult = result;
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
13000   int jresult ;
13001   int result;
13002
13003   result = (int)(int)Dali::Property::INVALID_KEY;
13004   jresult = result;
13005   return jresult;
13006 }
13007
13008
13009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13010   int jresult ;
13011   int result;
13012
13013   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13014   jresult = result;
13015   return jresult;
13016 }
13017
13018
13019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13020   void * jresult ;
13021   Dali::Handle *arg1 = 0 ;
13022   Dali::Property::Index arg2 ;
13023   Dali::Property *result = 0 ;
13024
13025   arg1 = (Dali::Handle *)jarg1;
13026   if (!arg1) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13028     return 0;
13029   }
13030   arg2 = (Dali::Property::Index)jarg2;
13031   {
13032     try {
13033       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13034     } catch (std::out_of_range& e) {
13035       {
13036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13037       };
13038     } catch (std::exception& e) {
13039       {
13040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13041       };
13042     } catch (...) {
13043       {
13044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13045       };
13046     }
13047   }
13048   jresult = (void *)result;
13049   return jresult;
13050 }
13051
13052
13053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13054   void * jresult ;
13055   Dali::Handle *arg1 = 0 ;
13056   Dali::Property::Index arg2 ;
13057   int arg3 ;
13058   Dali::Property *result = 0 ;
13059
13060   arg1 = (Dali::Handle *)jarg1;
13061   if (!arg1) {
13062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13063     return 0;
13064   }
13065   arg2 = (Dali::Property::Index)jarg2;
13066   arg3 = (int)jarg3;
13067   {
13068     try {
13069       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084   jresult = (void *)result;
13085   return jresult;
13086 }
13087
13088
13089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13090   void * jresult ;
13091   Dali::Handle *arg1 = 0 ;
13092   std::string *arg2 = 0 ;
13093   Dali::Property *result = 0 ;
13094
13095   arg1 = (Dali::Handle *)jarg1;
13096   if (!arg1) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13098     return 0;
13099   }
13100   if (!jarg2) {
13101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13102     return 0;
13103   }
13104   std::string arg2_str(jarg2);
13105   arg2 = &arg2_str;
13106   {
13107     try {
13108       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (...) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13120       };
13121     }
13122   }
13123   jresult = (void *)result;
13124
13125   //argout typemap for const std::string&
13126
13127   return jresult;
13128 }
13129
13130
13131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13132   void * jresult ;
13133   Dali::Handle *arg1 = 0 ;
13134   std::string *arg2 = 0 ;
13135   int arg3 ;
13136   Dali::Property *result = 0 ;
13137
13138   arg1 = (Dali::Handle *)jarg1;
13139   if (!arg1) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13141     return 0;
13142   }
13143   if (!jarg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13145     return 0;
13146   }
13147   std::string arg2_str(jarg2);
13148   arg2 = &arg2_str;
13149   arg3 = (int)jarg3;
13150   {
13151     try {
13152       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13153     } catch (std::out_of_range& e) {
13154       {
13155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13156       };
13157     } catch (std::exception& e) {
13158       {
13159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13160       };
13161     } catch (...) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13164       };
13165     }
13166   }
13167   jresult = (void *)result;
13168
13169   //argout typemap for const std::string&
13170
13171   return jresult;
13172 }
13173
13174
13175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177
13178   arg1 = (Dali::Property *)jarg1;
13179   {
13180     try {
13181       delete arg1;
13182     } catch (std::out_of_range& e) {
13183       {
13184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13185       };
13186     } catch (std::exception& e) {
13187       {
13188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13189       };
13190     } catch (...) {
13191       {
13192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13193       };
13194     }
13195   }
13196 }
13197
13198
13199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13200   Dali::Property *arg1 = (Dali::Property *) 0 ;
13201   Dali::Handle *arg2 = 0 ;
13202
13203   arg1 = (Dali::Property *)jarg1;
13204   arg2 = (Dali::Handle *)jarg2;
13205   if (!arg2) {
13206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13207     return ;
13208   }
13209   if (arg1) (arg1)->object = *arg2;
13210 }
13211
13212
13213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13214   void * jresult ;
13215   Dali::Property *arg1 = (Dali::Property *) 0 ;
13216   Dali::Handle *result = 0 ;
13217
13218   arg1 = (Dali::Property *)jarg1;
13219   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13220   jresult = (void *)result;
13221   return jresult;
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13226   Dali::Property *arg1 = (Dali::Property *) 0 ;
13227   Dali::Property::Index arg2 ;
13228
13229   arg1 = (Dali::Property *)jarg1;
13230   arg2 = (Dali::Property::Index)jarg2;
13231   if (arg1) (arg1)->propertyIndex = arg2;
13232 }
13233
13234
13235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13236   int jresult ;
13237   Dali::Property *arg1 = (Dali::Property *) 0 ;
13238   Dali::Property::Index result;
13239
13240   arg1 = (Dali::Property *)jarg1;
13241   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13242   jresult = result;
13243   return jresult;
13244 }
13245
13246
13247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13248   Dali::Property *arg1 = (Dali::Property *) 0 ;
13249   int arg2 ;
13250
13251   arg1 = (Dali::Property *)jarg1;
13252   arg2 = (int)jarg2;
13253   if (arg1) (arg1)->componentIndex = arg2;
13254 }
13255
13256
13257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13258   int jresult ;
13259   Dali::Property *arg1 = (Dali::Property *) 0 ;
13260   int result;
13261
13262   arg1 = (Dali::Property *)jarg1;
13263   result = (int) ((arg1)->componentIndex);
13264   jresult = result;
13265   return jresult;
13266 }
13267
13268
13269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13270   void * jresult ;
13271   Dali::Property::Array *result = 0 ;
13272
13273   {
13274     try {
13275       result = (Dali::Property::Array *)new Dali::Property::Array();
13276     } catch (std::out_of_range& e) {
13277       {
13278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13279       };
13280     } catch (std::exception& e) {
13281       {
13282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13283       };
13284     } catch (...) {
13285       {
13286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13287       };
13288     }
13289   }
13290   jresult = (void *)result;
13291   return jresult;
13292 }
13293
13294
13295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13296   void * jresult ;
13297   Dali::Property::Array *arg1 = 0 ;
13298   Dali::Property::Array *result = 0 ;
13299
13300   arg1 = (Dali::Property::Array *)jarg1;
13301   if (!arg1) {
13302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13303     return 0;
13304   }
13305   {
13306     try {
13307       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13308     } catch (std::out_of_range& e) {
13309       {
13310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13311       };
13312     } catch (std::exception& e) {
13313       {
13314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13315       };
13316     } catch (...) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13319       };
13320     }
13321   }
13322   jresult = (void *)result;
13323   return jresult;
13324 }
13325
13326
13327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13328   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13329
13330   arg1 = (Dali::Property::Array *)jarg1;
13331   {
13332     try {
13333       delete arg1;
13334     } catch (std::out_of_range& e) {
13335       {
13336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13337       };
13338     } catch (std::exception& e) {
13339       {
13340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13345       };
13346     }
13347   }
13348 }
13349
13350
13351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13352   unsigned long jresult ;
13353   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13354   Dali::Property::Array::SizeType result;
13355
13356   arg1 = (Dali::Property::Array *)jarg1;
13357   {
13358     try {
13359       result = ((Dali::Property::Array const *)arg1)->Size();
13360     } catch (std::out_of_range& e) {
13361       {
13362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13363       };
13364     } catch (std::exception& e) {
13365       {
13366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13367       };
13368     } catch (...) {
13369       {
13370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13371       };
13372     }
13373   }
13374   jresult = (unsigned long)result;
13375   return jresult;
13376 }
13377
13378
13379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13380   unsigned long jresult ;
13381   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13382   Dali::Property::Array::SizeType result;
13383
13384   arg1 = (Dali::Property::Array *)jarg1;
13385   {
13386     try {
13387       result = ((Dali::Property::Array const *)arg1)->Count();
13388     } catch (std::out_of_range& e) {
13389       {
13390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13391       };
13392     } catch (std::exception& e) {
13393       {
13394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13395       };
13396     } catch (...) {
13397       {
13398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13399       };
13400     }
13401   }
13402   jresult = (unsigned long)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13408   unsigned int jresult ;
13409   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13410   bool result;
13411
13412   arg1 = (Dali::Property::Array *)jarg1;
13413   {
13414     try {
13415       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13416     } catch (std::out_of_range& e) {
13417       {
13418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (std::exception& e) {
13421       {
13422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430   jresult = result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13436   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13437
13438   arg1 = (Dali::Property::Array *)jarg1;
13439   {
13440     try {
13441       (arg1)->Clear();
13442     } catch (std::out_of_range& e) {
13443       {
13444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13445       };
13446     } catch (std::exception& e) {
13447       {
13448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13453       };
13454     }
13455   }
13456 }
13457
13458
13459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13460   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13461   Dali::Property::Array::SizeType arg2 ;
13462
13463   arg1 = (Dali::Property::Array *)jarg1;
13464   arg2 = (Dali::Property::Array::SizeType)jarg2;
13465   {
13466     try {
13467       (arg1)->Reserve(arg2);
13468     } catch (std::out_of_range& e) {
13469       {
13470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13471       };
13472     } catch (std::exception& e) {
13473       {
13474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13475       };
13476     } catch (...) {
13477       {
13478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13479       };
13480     }
13481   }
13482 }
13483
13484
13485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13486   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13487   Dali::Property::Array::SizeType arg2 ;
13488
13489   arg1 = (Dali::Property::Array *)jarg1;
13490   arg2 = (Dali::Property::Array::SizeType)jarg2;
13491   {
13492     try {
13493       (arg1)->Resize(arg2);
13494     } catch (std::out_of_range& e) {
13495       {
13496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13497       };
13498     } catch (std::exception& e) {
13499       {
13500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13501       };
13502     } catch (...) {
13503       {
13504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13505       };
13506     }
13507   }
13508 }
13509
13510
13511 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13512   unsigned long jresult ;
13513   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13514   Dali::Property::Array::SizeType result;
13515
13516   arg1 = (Dali::Property::Array *)jarg1;
13517   {
13518     try {
13519       result = (arg1)->Capacity();
13520     } catch (std::out_of_range& e) {
13521       {
13522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13523       };
13524     } catch (std::exception& e) {
13525       {
13526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13527       };
13528     } catch (...) {
13529       {
13530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13531       };
13532     }
13533   }
13534   jresult = (unsigned long)result;
13535   return jresult;
13536 }
13537
13538
13539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13540   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13541   Dali::Property::Value *arg2 = 0 ;
13542
13543   arg1 = (Dali::Property::Array *)jarg1;
13544   arg2 = (Dali::Property::Value *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13547     return ;
13548   }
13549   {
13550     try {
13551       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13552     } catch (std::out_of_range& e) {
13553       {
13554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13555       };
13556     } catch (std::exception& e) {
13557       {
13558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13559       };
13560     } catch (...) {
13561       {
13562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13563       };
13564     }
13565   }
13566 }
13567
13568
13569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13570   void * jresult ;
13571   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13572   Dali::Property::Value *arg2 = 0 ;
13573   Dali::Property::Array *result = 0 ;
13574
13575   arg1 = (Dali::Property::Array *)jarg1;
13576   arg2 = (Dali::Property::Value *)jarg2;
13577   if (!arg2) {
13578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13579     return 0;
13580   }
13581   {
13582     try {
13583       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13584     } catch (std::out_of_range& e) {
13585       {
13586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13587       };
13588     } catch (std::exception& e) {
13589       {
13590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13591       };
13592     } catch (...) {
13593       {
13594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13595       };
13596     }
13597   }
13598   jresult = (void *)result;
13599   return jresult;
13600 }
13601
13602
13603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13604   void * jresult ;
13605   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13606   Dali::Property::Array::SizeType arg2 ;
13607   Dali::Property::Value *result = 0 ;
13608
13609   arg1 = (Dali::Property::Array *)jarg1;
13610   arg2 = (Dali::Property::Array::SizeType)jarg2;
13611   {
13612     try {
13613       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13614     } catch (std::out_of_range& e) {
13615       {
13616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13617       };
13618     } catch (std::exception& e) {
13619       {
13620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (...) {
13623       {
13624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13625       };
13626     }
13627   }
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13634   void * jresult ;
13635   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13636   Dali::Property::Array::SizeType arg2 ;
13637   Dali::Property::Value *result = 0 ;
13638
13639   arg1 = (Dali::Property::Array *)jarg1;
13640   arg2 = (Dali::Property::Array::SizeType)jarg2;
13641   {
13642     try {
13643       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (...) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13655       };
13656     }
13657   }
13658   jresult = (void *)result;
13659   return jresult;
13660 }
13661
13662
13663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13664   void * jresult ;
13665   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13666   Dali::Property::Array *arg2 = 0 ;
13667   Dali::Property::Array *result = 0 ;
13668
13669   arg1 = (Dali::Property::Array *)jarg1;
13670   arg2 = (Dali::Property::Array *)jarg2;
13671   if (!arg2) {
13672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13673     return 0;
13674   }
13675   {
13676     try {
13677       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13678     } catch (std::out_of_range& e) {
13679       {
13680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13681       };
13682     } catch (std::exception& e) {
13683       {
13684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13685       };
13686     } catch (...) {
13687       {
13688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13689       };
13690     }
13691   }
13692   jresult = (void *)result;
13693   return jresult;
13694 }
13695
13696
13697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13698   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13699   enum Dali::Property::Key::Type arg2 ;
13700
13701   arg1 = (Dali::Property::Key *)jarg1;
13702   arg2 = (enum Dali::Property::Key::Type)jarg2;
13703   if (arg1) (arg1)->type = arg2;
13704 }
13705
13706
13707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13708   int jresult ;
13709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13710   enum Dali::Property::Key::Type result;
13711
13712   arg1 = (Dali::Property::Key *)jarg1;
13713   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13714   jresult = (int)result;
13715   return jresult;
13716 }
13717
13718
13719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13720   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13721   Dali::Property::Index arg2 ;
13722
13723   arg1 = (Dali::Property::Key *)jarg1;
13724   arg2 = (Dali::Property::Index)jarg2;
13725   if (arg1) (arg1)->indexKey = arg2;
13726 }
13727
13728
13729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13730   int jresult ;
13731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13732   Dali::Property::Index result;
13733
13734   arg1 = (Dali::Property::Key *)jarg1;
13735   result = (Dali::Property::Index) ((arg1)->indexKey);
13736   jresult = result;
13737   return jresult;
13738 }
13739
13740
13741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13743   std::string *arg2 = 0 ;
13744
13745   arg1 = (Dali::Property::Key *)jarg1;
13746   if (!jarg2) {
13747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13748     return ;
13749   }
13750   std::string arg2_str(jarg2);
13751   arg2 = &arg2_str;
13752   if (arg1) (arg1)->stringKey = *arg2;
13753
13754   //argout typemap for const std::string&
13755
13756 }
13757
13758
13759 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13760   char * jresult ;
13761   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13762   std::string *result = 0 ;
13763
13764   arg1 = (Dali::Property::Key *)jarg1;
13765   result = (std::string *) & ((arg1)->stringKey);
13766   jresult = SWIG_csharp_string_callback(result->c_str());
13767   return jresult;
13768 }
13769
13770
13771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13772   void * jresult ;
13773   std::string *arg1 = 0 ;
13774   Dali::Property::Key *result = 0 ;
13775
13776   if (!jarg1) {
13777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13778     return 0;
13779   }
13780   std::string arg1_str(jarg1);
13781   arg1 = &arg1_str;
13782   {
13783     try {
13784       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13785     } catch (std::out_of_range& e) {
13786       {
13787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (std::exception& e) {
13790       {
13791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799   jresult = (void *)result;
13800
13801   //argout typemap for const std::string&
13802
13803   return jresult;
13804 }
13805
13806
13807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13808   void * jresult ;
13809   Dali::Property::Index arg1 ;
13810   Dali::Property::Key *result = 0 ;
13811
13812   arg1 = (Dali::Property::Index)jarg1;
13813   {
13814     try {
13815       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13816     } catch (std::out_of_range& e) {
13817       {
13818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (std::exception& e) {
13821       {
13822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830   jresult = (void *)result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13836   unsigned int jresult ;
13837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13838   std::string *arg2 = 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Property::Key *)jarg1;
13842   if (!jarg2) {
13843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13844     return 0;
13845   }
13846   std::string arg2_str(jarg2);
13847   arg2 = &arg2_str;
13848   {
13849     try {
13850       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13851     } catch (std::out_of_range& e) {
13852       {
13853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (std::exception& e) {
13856       {
13857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865   jresult = result;
13866
13867   //argout typemap for const std::string&
13868
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13874   unsigned int jresult ;
13875   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13876   Dali::Property::Index arg2 ;
13877   bool result;
13878
13879   arg1 = (Dali::Property::Key *)jarg1;
13880   arg2 = (Dali::Property::Index)jarg2;
13881   {
13882     try {
13883       result = (bool)(arg1)->operator ==(arg2);
13884     } catch (std::out_of_range& e) {
13885       {
13886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (std::exception& e) {
13889       {
13890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13895       };
13896     }
13897   }
13898   jresult = result;
13899   return jresult;
13900 }
13901
13902
13903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13904   unsigned int jresult ;
13905   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13906   Dali::Property::Key *arg2 = 0 ;
13907   bool result;
13908
13909   arg1 = (Dali::Property::Key *)jarg1;
13910   arg2 = (Dali::Property::Key *)jarg2;
13911   if (!arg2) {
13912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13913     return 0;
13914   }
13915   {
13916     try {
13917       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13918     } catch (std::out_of_range& e) {
13919       {
13920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (std::exception& e) {
13923       {
13924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932   jresult = result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13938   unsigned int jresult ;
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940   std::string *arg2 = 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Property::Key *)jarg1;
13944   if (!jarg2) {
13945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13946     return 0;
13947   }
13948   std::string arg2_str(jarg2);
13949   arg2 = &arg2_str;
13950   {
13951     try {
13952       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13953     } catch (std::out_of_range& e) {
13954       {
13955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13956       };
13957     } catch (std::exception& e) {
13958       {
13959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13960       };
13961     } catch (...) {
13962       {
13963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13964       };
13965     }
13966   }
13967   jresult = result;
13968
13969   //argout typemap for const std::string&
13970
13971   return jresult;
13972 }
13973
13974
13975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13976   unsigned int jresult ;
13977   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13978   Dali::Property::Index arg2 ;
13979   bool result;
13980
13981   arg1 = (Dali::Property::Key *)jarg1;
13982   arg2 = (Dali::Property::Index)jarg2;
13983   {
13984     try {
13985       result = (bool)(arg1)->operator !=(arg2);
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (...) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13997       };
13998     }
13999   }
14000   jresult = result;
14001   return jresult;
14002 }
14003
14004
14005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14006   unsigned int jresult ;
14007   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14008   Dali::Property::Key *arg2 = 0 ;
14009   bool result;
14010
14011   arg1 = (Dali::Property::Key *)jarg1;
14012   arg2 = (Dali::Property::Key *)jarg2;
14013   if (!arg2) {
14014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14015     return 0;
14016   }
14017   {
14018     try {
14019       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14020     } catch (std::out_of_range& e) {
14021       {
14022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14023       };
14024     } catch (std::exception& e) {
14025       {
14026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (...) {
14029       {
14030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14031       };
14032     }
14033   }
14034   jresult = result;
14035   return jresult;
14036 }
14037
14038
14039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14040   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14041
14042   arg1 = (Dali::Property::Key *)jarg1;
14043   {
14044     try {
14045       delete arg1;
14046     } catch (std::out_of_range& e) {
14047       {
14048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14049       };
14050     } catch (std::exception& e) {
14051       {
14052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14057       };
14058     }
14059   }
14060 }
14061
14062
14063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14064   void * jresult ;
14065   Dali::Property::Map *result = 0 ;
14066
14067   {
14068     try {
14069       result = (Dali::Property::Map *)new Dali::Property::Map();
14070     } catch (std::out_of_range& e) {
14071       {
14072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14073       };
14074     } catch (std::exception& e) {
14075       {
14076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14077       };
14078     } catch (...) {
14079       {
14080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14081       };
14082     }
14083   }
14084   jresult = (void *)result;
14085   return jresult;
14086 }
14087
14088
14089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14090   void * jresult ;
14091   Dali::Property::Map *arg1 = 0 ;
14092   Dali::Property::Map *result = 0 ;
14093
14094   arg1 = (Dali::Property::Map *)jarg1;
14095   if (!arg1) {
14096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14097     return 0;
14098   }
14099   {
14100     try {
14101       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14102     } catch (std::out_of_range& e) {
14103       {
14104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14105       };
14106     } catch (std::exception& e) {
14107       {
14108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14109       };
14110     } catch (...) {
14111       {
14112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14113       };
14114     }
14115   }
14116   jresult = (void *)result;
14117   return jresult;
14118 }
14119
14120
14121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14122   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14123
14124   arg1 = (Dali::Property::Map *)jarg1;
14125   {
14126     try {
14127       delete arg1;
14128     } catch (std::out_of_range& e) {
14129       {
14130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14131       };
14132     } catch (std::exception& e) {
14133       {
14134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14135       };
14136     } catch (...) {
14137       {
14138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14139       };
14140     }
14141   }
14142 }
14143
14144
14145 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14146   unsigned long jresult ;
14147   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14148   Dali::Property::Map::SizeType result;
14149
14150   arg1 = (Dali::Property::Map *)jarg1;
14151   {
14152     try {
14153       result = ((Dali::Property::Map const *)arg1)->Count();
14154     } catch (std::out_of_range& e) {
14155       {
14156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14157       };
14158     } catch (std::exception& e) {
14159       {
14160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14161       };
14162     } catch (...) {
14163       {
14164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14165       };
14166     }
14167   }
14168   jresult = (unsigned long)result;
14169   return jresult;
14170 }
14171
14172
14173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14174   unsigned int jresult ;
14175   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14176   bool result;
14177
14178   arg1 = (Dali::Property::Map *)jarg1;
14179   {
14180     try {
14181       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
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 = result;
14197   return jresult;
14198 }
14199
14200
14201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14202   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14203   char *arg2 = (char *) 0 ;
14204   Dali::Property::Value *arg3 = 0 ;
14205
14206   arg1 = (Dali::Property::Map *)jarg1;
14207   arg2 = (char *)jarg2;
14208   arg3 = (Dali::Property::Value *)jarg3;
14209   if (!arg3) {
14210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14211     return ;
14212   }
14213   {
14214     try {
14215       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14216     } catch (std::out_of_range& e) {
14217       {
14218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14219       };
14220     } catch (std::exception& e) {
14221       {
14222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14223       };
14224     } catch (...) {
14225       {
14226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14227       };
14228     }
14229   }
14230 }
14231
14232
14233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14235   Dali::Property::Index arg2 ;
14236   Dali::Property::Value *arg3 = 0 ;
14237
14238   arg1 = (Dali::Property::Map *)jarg1;
14239   arg2 = (Dali::Property::Index)jarg2;
14240   arg3 = (Dali::Property::Value *)jarg3;
14241   if (!arg3) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14243     return ;
14244   }
14245   {
14246     try {
14247       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14255       };
14256     } catch (...) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14259       };
14260     }
14261   }
14262 }
14263
14264
14265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14266   void * jresult ;
14267   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14268   char *arg2 = (char *) 0 ;
14269   Dali::Property::Value *arg3 = 0 ;
14270   Dali::Property::Map *result = 0 ;
14271
14272   arg1 = (Dali::Property::Map *)jarg1;
14273   arg2 = (char *)jarg2;
14274   arg3 = (Dali::Property::Value *)jarg3;
14275   if (!arg3) {
14276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14277     return 0;
14278   }
14279   {
14280     try {
14281       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14282     } catch (std::out_of_range& e) {
14283       {
14284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14285       };
14286     } catch (std::exception& e) {
14287       {
14288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14289       };
14290     } catch (...) {
14291       {
14292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14293       };
14294     }
14295   }
14296   jresult = (void *)result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14302   void * jresult ;
14303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14304   Dali::Property::Index arg2 ;
14305   Dali::Property::Value *arg3 = 0 ;
14306   Dali::Property::Map *result = 0 ;
14307
14308   arg1 = (Dali::Property::Map *)jarg1;
14309   arg2 = (Dali::Property::Index)jarg2;
14310   arg3 = (Dali::Property::Value *)jarg3;
14311   if (!arg3) {
14312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14313     return 0;
14314   }
14315   {
14316     try {
14317       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14318     } catch (std::out_of_range& e) {
14319       {
14320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (std::exception& e) {
14323       {
14324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332   jresult = (void *)result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14338   void * jresult ;
14339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14340   Dali::Property::Map::SizeType arg2 ;
14341   Dali::Property::Value *result = 0 ;
14342
14343   arg1 = (Dali::Property::Map *)jarg1;
14344   arg2 = (Dali::Property::Map::SizeType)jarg2;
14345   {
14346     try {
14347       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (...) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14359       };
14360     }
14361   }
14362   jresult = (void *)result;
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14368   char * jresult ;
14369   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14370   Dali::Property::Map::SizeType arg2 ;
14371   std::string *result = 0 ;
14372
14373   arg1 = (Dali::Property::Map *)jarg1;
14374   arg2 = (Dali::Property::Map::SizeType)jarg2;
14375   {
14376     try {
14377       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14378     } catch (std::out_of_range& e) {
14379       {
14380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14381       };
14382     } catch (std::exception& e) {
14383       {
14384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (...) {
14387       {
14388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14389       };
14390     }
14391   }
14392   jresult = SWIG_csharp_string_callback(result->c_str());
14393   return jresult;
14394 }
14395
14396
14397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14398   void * jresult ;
14399   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14400   Dali::Property::Map::SizeType arg2 ;
14401   SwigValueWrapper< Dali::Property::Key > result;
14402
14403   arg1 = (Dali::Property::Map *)jarg1;
14404   arg2 = (Dali::Property::Map::SizeType)jarg2;
14405   {
14406     try {
14407       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14408     } catch (std::out_of_range& e) {
14409       {
14410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14411       };
14412     } catch (std::exception& e) {
14413       {
14414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14415       };
14416     } catch (...) {
14417       {
14418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14419       };
14420     }
14421   }
14422   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14428   void * jresult ;
14429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14430   Dali::Property::Map::SizeType arg2 ;
14431   StringValuePair *result = 0 ;
14432
14433   arg1 = (Dali::Property::Map *)jarg1;
14434   arg2 = (Dali::Property::Map::SizeType)jarg2;
14435   {
14436     try {
14437       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14438     } catch (std::out_of_range& e) {
14439       {
14440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14441       };
14442     } catch (std::exception& e) {
14443       {
14444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (...) {
14447       {
14448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14449       };
14450     }
14451   }
14452   jresult = (void *)result;
14453   return jresult;
14454 }
14455
14456
14457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14458   void * jresult ;
14459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14460   char *arg2 = (char *) 0 ;
14461   Dali::Property::Value *result = 0 ;
14462
14463   arg1 = (Dali::Property::Map *)jarg1;
14464   arg2 = (char *)jarg2;
14465   {
14466     try {
14467       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14468     } catch (std::out_of_range& e) {
14469       {
14470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14471       };
14472     } catch (std::exception& e) {
14473       {
14474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14475       };
14476     } catch (...) {
14477       {
14478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14479       };
14480     }
14481   }
14482   jresult = (void *)result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14488   void * jresult ;
14489   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14490   Dali::Property::Index arg2 ;
14491   Dali::Property::Value *result = 0 ;
14492
14493   arg1 = (Dali::Property::Map *)jarg1;
14494   arg2 = (Dali::Property::Index)jarg2;
14495   {
14496     try {
14497       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14498     } catch (std::out_of_range& e) {
14499       {
14500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14501       };
14502     } catch (std::exception& e) {
14503       {
14504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14505       };
14506     } catch (...) {
14507       {
14508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14509       };
14510     }
14511   }
14512   jresult = (void *)result;
14513   return jresult;
14514 }
14515
14516
14517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14518   void * jresult ;
14519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14520   Dali::Property::Index arg2 ;
14521   std::string *arg3 = 0 ;
14522   Dali::Property::Value *result = 0 ;
14523
14524   arg1 = (Dali::Property::Map *)jarg1;
14525   arg2 = (Dali::Property::Index)jarg2;
14526   if (!jarg3) {
14527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14528     return 0;
14529   }
14530   std::string arg3_str(jarg3);
14531   arg3 = &arg3_str;
14532   {
14533     try {
14534       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14546       };
14547     }
14548   }
14549   jresult = (void *)result;
14550
14551   //argout typemap for const std::string&
14552
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14558   void * jresult ;
14559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14560   std::string *arg2 = 0 ;
14561   Dali::Property::Type arg3 ;
14562   Dali::Property::Value *result = 0 ;
14563
14564   arg1 = (Dali::Property::Map *)jarg1;
14565   if (!jarg2) {
14566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14567     return 0;
14568   }
14569   std::string arg2_str(jarg2);
14570   arg2 = &arg2_str;
14571   arg3 = (Dali::Property::Type)jarg3;
14572   {
14573     try {
14574       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14575     } catch (std::out_of_range& e) {
14576       {
14577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14578       };
14579     } catch (std::exception& e) {
14580       {
14581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14582       };
14583     } catch (...) {
14584       {
14585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14586       };
14587     }
14588   }
14589   jresult = (void *)result;
14590
14591   //argout typemap for const std::string&
14592
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14598   void * jresult ;
14599   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14600   Dali::Property::Index arg2 ;
14601   Dali::Property::Type arg3 ;
14602   Dali::Property::Value *result = 0 ;
14603
14604   arg1 = (Dali::Property::Map *)jarg1;
14605   arg2 = (Dali::Property::Index)jarg2;
14606   arg3 = (Dali::Property::Type)jarg3;
14607   {
14608     try {
14609       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14610     } catch (std::out_of_range& e) {
14611       {
14612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14613       };
14614     } catch (std::exception& e) {
14615       {
14616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14617       };
14618     } catch (...) {
14619       {
14620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14621       };
14622     }
14623   }
14624   jresult = (void *)result;
14625   return jresult;
14626 }
14627
14628
14629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14630   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14631
14632   arg1 = (Dali::Property::Map *)jarg1;
14633   {
14634     try {
14635       (arg1)->Clear();
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14643       };
14644     } catch (...) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14647       };
14648     }
14649   }
14650 }
14651
14652
14653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14654   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14655   Dali::Property::Map *arg2 = 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 ;
14662   }
14663   {
14664     try {
14665       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14666     } catch (std::out_of_range& e) {
14667       {
14668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14669       };
14670     } catch (std::exception& e) {
14671       {
14672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14673       };
14674     } catch (...) {
14675       {
14676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14677       };
14678     }
14679   }
14680 }
14681
14682
14683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14684   void * jresult ;
14685   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14686   std::string *arg2 = 0 ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   arg1 = (Dali::Property::Map *)jarg1;
14690   if (!jarg2) {
14691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14692     return 0;
14693   }
14694   std::string arg2_str(jarg2);
14695   arg2 = &arg2_str;
14696   {
14697     try {
14698       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14699     } catch (std::out_of_range& e) {
14700       {
14701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14702       };
14703     } catch (std::exception& e) {
14704       {
14705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14706       };
14707     } catch (...) {
14708       {
14709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14710       };
14711     }
14712   }
14713   jresult = (void *)result;
14714
14715   //argout typemap for const std::string&
14716
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14722   void * jresult ;
14723   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14724   Dali::Property::Index arg2 ;
14725   Dali::Property::Value *result = 0 ;
14726
14727   arg1 = (Dali::Property::Map *)jarg1;
14728   arg2 = (Dali::Property::Index)jarg2;
14729   {
14730     try {
14731       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14732     } catch (std::out_of_range& e) {
14733       {
14734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14735       };
14736     } catch (std::exception& e) {
14737       {
14738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (...) {
14741       {
14742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14743       };
14744     }
14745   }
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14752   void * jresult ;
14753   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14754   Dali::Property::Map *arg2 = 0 ;
14755   Dali::Property::Map *result = 0 ;
14756
14757   arg1 = (Dali::Property::Map *)jarg1;
14758   arg2 = (Dali::Property::Map *)jarg2;
14759   if (!arg2) {
14760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14761     return 0;
14762   }
14763   {
14764     try {
14765       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14766     } catch (std::out_of_range& e) {
14767       {
14768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (std::exception& e) {
14771       {
14772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14786   void * jresult ;
14787   Dali::Property::Value *result = 0 ;
14788
14789   {
14790     try {
14791       result = (Dali::Property::Value *)new Dali::Property::Value();
14792     } catch (std::out_of_range& e) {
14793       {
14794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14795       };
14796     } catch (std::exception& e) {
14797       {
14798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14803       };
14804     }
14805   }
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14812   void * jresult ;
14813   bool arg1 ;
14814   Dali::Property::Value *result = 0 ;
14815
14816   arg1 = jarg1 ? true : false;
14817   {
14818     try {
14819       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14820     } catch (std::out_of_range& e) {
14821       {
14822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14823       };
14824     } catch (std::exception& e) {
14825       {
14826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14827       };
14828     } catch (...) {
14829       {
14830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14831       };
14832     }
14833   }
14834   jresult = (void *)result;
14835   return jresult;
14836 }
14837
14838
14839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14840   void * jresult ;
14841   int arg1 ;
14842   Dali::Property::Value *result = 0 ;
14843
14844   arg1 = (int)jarg1;
14845   {
14846     try {
14847       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14848     } catch (std::out_of_range& e) {
14849       {
14850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14851       };
14852     } catch (std::exception& e) {
14853       {
14854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14855       };
14856     } catch (...) {
14857       {
14858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14859       };
14860     }
14861   }
14862   jresult = (void *)result;
14863   return jresult;
14864 }
14865
14866
14867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14868   void * jresult ;
14869   float arg1 ;
14870   Dali::Property::Value *result = 0 ;
14871
14872   arg1 = (float)jarg1;
14873   {
14874     try {
14875       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14876     } catch (std::out_of_range& e) {
14877       {
14878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14879       };
14880     } catch (std::exception& e) {
14881       {
14882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14883       };
14884     } catch (...) {
14885       {
14886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14887       };
14888     }
14889   }
14890   jresult = (void *)result;
14891   return jresult;
14892 }
14893
14894
14895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14896   void * jresult ;
14897   Dali::Vector2 *arg1 = 0 ;
14898   Dali::Property::Value *result = 0 ;
14899
14900   arg1 = (Dali::Vector2 *)jarg1;
14901   if (!arg1) {
14902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14903     return 0;
14904   }
14905   {
14906     try {
14907       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14908     } catch (std::out_of_range& e) {
14909       {
14910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (std::exception& e) {
14913       {
14914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14915       };
14916     } catch (...) {
14917       {
14918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14919       };
14920     }
14921   }
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14928   void * jresult ;
14929   Dali::Vector3 *arg1 = 0 ;
14930   Dali::Property::Value *result = 0 ;
14931
14932   arg1 = (Dali::Vector3 *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (...) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14951       };
14952     }
14953   }
14954   jresult = (void *)result;
14955   return jresult;
14956 }
14957
14958
14959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14960   void * jresult ;
14961   Dali::Vector4 *arg1 = 0 ;
14962   Dali::Property::Value *result = 0 ;
14963
14964   arg1 = (Dali::Vector4 *)jarg1;
14965   if (!arg1) {
14966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14967     return 0;
14968   }
14969   {
14970     try {
14971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14972     } catch (std::out_of_range& e) {
14973       {
14974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14975       };
14976     } catch (std::exception& e) {
14977       {
14978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14983       };
14984     }
14985   }
14986   jresult = (void *)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14992   void * jresult ;
14993   Dali::Matrix3 *arg1 = 0 ;
14994   Dali::Property::Value *result = 0 ;
14995
14996   arg1 = (Dali::Matrix3 *)jarg1;
14997   if (!arg1) {
14998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14999     return 0;
15000   }
15001   {
15002     try {
15003       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15004     } catch (std::out_of_range& e) {
15005       {
15006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (std::exception& e) {
15009       {
15010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018   jresult = (void *)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15024   void * jresult ;
15025   Dali::Matrix *arg1 = 0 ;
15026   Dali::Property::Value *result = 0 ;
15027
15028   arg1 = (Dali::Matrix *)jarg1;
15029   if (!arg1) {
15030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15031     return 0;
15032   }
15033   {
15034     try {
15035       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15036     } catch (std::out_of_range& e) {
15037       {
15038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (std::exception& e) {
15041       {
15042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050   jresult = (void *)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15056   void * jresult ;
15057   Dali::Rect< int > *arg1 = 0 ;
15058   Dali::Property::Value *result = 0 ;
15059
15060   arg1 = (Dali::Rect< int > *)jarg1;
15061   if (!arg1) {
15062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15063     return 0;
15064   }
15065   {
15066     try {
15067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (...) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15079       };
15080     }
15081   }
15082   jresult = (void *)result;
15083   return jresult;
15084 }
15085
15086
15087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15088   void * jresult ;
15089   Dali::AngleAxis *arg1 = 0 ;
15090   Dali::Property::Value *result = 0 ;
15091
15092   arg1 = (Dali::AngleAxis *)jarg1;
15093   if (!arg1) {
15094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15095     return 0;
15096   }
15097   {
15098     try {
15099       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*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_11(void * jarg1) {
15120   void * jresult ;
15121   Dali::Quaternion *arg1 = 0 ;
15122   Dali::Property::Value *result = 0 ;
15123
15124   arg1 = (Dali::Quaternion *)jarg1;
15125   if (!arg1) {
15126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15127     return 0;
15128   }
15129   {
15130     try {
15131       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*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_12(char * jarg1) {
15152   void * jresult ;
15153   std::string *arg1 = 0 ;
15154   Dali::Property::Value *result = 0 ;
15155
15156   if (!jarg1) {
15157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15158     return 0;
15159   }
15160   std::string arg1_str(jarg1);
15161   arg1 = &arg1_str;
15162   {
15163     try {
15164       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15165     } catch (std::out_of_range& e) {
15166       {
15167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15168       };
15169     } catch (std::exception& e) {
15170       {
15171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15176       };
15177     }
15178   }
15179   jresult = (void *)result;
15180
15181   //argout typemap for const std::string&
15182
15183   return jresult;
15184 }
15185
15186
15187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15188   void * jresult ;
15189   Dali::Property::Array *arg1 = 0 ;
15190   Dali::Property::Value *result = 0 ;
15191
15192   arg1 = (Dali::Property::Array *)jarg1;
15193   if (!arg1) {
15194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15195     return 0;
15196   }
15197   {
15198     try {
15199       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15200     } catch (std::out_of_range& e) {
15201       {
15202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15203       };
15204     } catch (std::exception& e) {
15205       {
15206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15207       };
15208     } catch (...) {
15209       {
15210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15211       };
15212     }
15213   }
15214   jresult = (void *)result;
15215   return jresult;
15216 }
15217
15218
15219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15220   void * jresult ;
15221   Dali::Property::Map *arg1 = 0 ;
15222   Dali::Property::Value *result = 0 ;
15223
15224   arg1 = (Dali::Property::Map *)jarg1;
15225   if (!arg1) {
15226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15227     return 0;
15228   }
15229   {
15230     try {
15231       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15232     } catch (std::out_of_range& e) {
15233       {
15234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15235       };
15236     } catch (std::exception& e) {
15237       {
15238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15239       };
15240     } catch (...) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15243       };
15244     }
15245   }
15246   jresult = (void *)result;
15247   return jresult;
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15252   void * jresult ;
15253   Dali::Property::Type arg1 ;
15254   Dali::Property::Value *result = 0 ;
15255
15256   arg1 = (Dali::Property::Type)jarg1;
15257   {
15258     try {
15259       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15260     } catch (std::out_of_range& e) {
15261       {
15262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15263       };
15264     } catch (std::exception& e) {
15265       {
15266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (...) {
15269       {
15270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15271       };
15272     }
15273   }
15274   jresult = (void *)result;
15275   return jresult;
15276 }
15277
15278
15279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15280   void * jresult ;
15281   Dali::Property::Value *arg1 = 0 ;
15282   Dali::Property::Value *result = 0 ;
15283
15284   arg1 = (Dali::Property::Value *)jarg1;
15285   if (!arg1) {
15286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15287     return 0;
15288   }
15289   {
15290     try {
15291       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15292     } catch (std::out_of_range& e) {
15293       {
15294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (std::exception& e) {
15297       {
15298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15312   void * jresult ;
15313   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15314   Dali::Property::Value *arg2 = 0 ;
15315   Dali::Property::Value *result = 0 ;
15316
15317   arg1 = (Dali::Property::Value *)jarg1;
15318   arg2 = (Dali::Property::Value *)jarg2;
15319   if (!arg2) {
15320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15321     return 0;
15322   }
15323   {
15324     try {
15325       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (...) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15337       };
15338     }
15339   }
15340   jresult = (void *)result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15347
15348   arg1 = (Dali::Property::Value *)jarg1;
15349   {
15350     try {
15351       delete arg1;
15352     } catch (std::out_of_range& e) {
15353       {
15354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15355       };
15356     } catch (std::exception& e) {
15357       {
15358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15359       };
15360     } catch (...) {
15361       {
15362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15363       };
15364     }
15365   }
15366 }
15367
15368
15369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15370   int jresult ;
15371   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15372   Dali::Property::Type result;
15373
15374   arg1 = (Dali::Property::Value *)jarg1;
15375   {
15376     try {
15377       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15378     } catch (std::out_of_range& e) {
15379       {
15380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (std::exception& e) {
15383       {
15384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15385       };
15386     } catch (...) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15389       };
15390     }
15391   }
15392   jresult = (int)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15398   unsigned int jresult ;
15399   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15400   bool *arg2 = 0 ;
15401   bool result;
15402
15403   arg1 = (Dali::Property::Value *)jarg1;
15404   arg2 = (bool *)jarg2;
15405   {
15406     try {
15407       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15408     } catch (std::out_of_range& e) {
15409       {
15410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15411       };
15412     } catch (std::exception& e) {
15413       {
15414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15415       };
15416     } catch (...) {
15417       {
15418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15419       };
15420     }
15421   }
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15428   unsigned int jresult ;
15429   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15430   float *arg2 = 0 ;
15431   bool result;
15432
15433   arg1 = (Dali::Property::Value *)jarg1;
15434   arg2 = (float *)jarg2;
15435   {
15436     try {
15437       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (...) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15449       };
15450     }
15451   }
15452   jresult = result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15458   unsigned int jresult ;
15459   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15460   int *arg2 = 0 ;
15461   bool result;
15462
15463   arg1 = (Dali::Property::Value *)jarg1;
15464   arg2 = (int *)jarg2;
15465   {
15466     try {
15467       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15468     } catch (std::out_of_range& e) {
15469       {
15470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15471       };
15472     } catch (std::exception& e) {
15473       {
15474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (...) {
15477       {
15478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15479       };
15480     }
15481   }
15482   jresult = result;
15483   return jresult;
15484 }
15485
15486
15487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15488   unsigned int jresult ;
15489   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15490   Dali::Rect< int > *arg2 = 0 ;
15491   bool result;
15492
15493   arg1 = (Dali::Property::Value *)jarg1;
15494   arg2 = (Dali::Rect< int > *)jarg2;
15495   if (!arg2) {
15496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15497     return 0;
15498   }
15499   {
15500     try {
15501       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15502     } catch (std::out_of_range& e) {
15503       {
15504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (std::exception& e) {
15507       {
15508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15509       };
15510     } catch (...) {
15511       {
15512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15513       };
15514     }
15515   }
15516   jresult = result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15522   unsigned int jresult ;
15523   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15524   Dali::Vector2 *arg2 = 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::Property::Value *)jarg1;
15528   arg2 = (Dali::Vector2 *)jarg2;
15529   if (!arg2) {
15530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15531     return 0;
15532   }
15533   {
15534     try {
15535       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15536     } catch (std::out_of_range& e) {
15537       {
15538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15539       };
15540     } catch (std::exception& e) {
15541       {
15542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (...) {
15545       {
15546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15547       };
15548     }
15549   }
15550   jresult = result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15556   unsigned int jresult ;
15557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15558   Dali::Vector3 *arg2 = 0 ;
15559   bool result;
15560
15561   arg1 = (Dali::Property::Value *)jarg1;
15562   arg2 = (Dali::Vector3 *)jarg2;
15563   if (!arg2) {
15564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15565     return 0;
15566   }
15567   {
15568     try {
15569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15570     } catch (std::out_of_range& e) {
15571       {
15572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (std::exception& e) {
15575       {
15576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15577       };
15578     } catch (...) {
15579       {
15580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15581       };
15582     }
15583   }
15584   jresult = result;
15585   return jresult;
15586 }
15587
15588
15589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15590   unsigned int jresult ;
15591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15592   Dali::Vector4 *arg2 = 0 ;
15593   bool result;
15594
15595   arg1 = (Dali::Property::Value *)jarg1;
15596   arg2 = (Dali::Vector4 *)jarg2;
15597   if (!arg2) {
15598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15599     return 0;
15600   }
15601   {
15602     try {
15603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15604     } catch (std::out_of_range& e) {
15605       {
15606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (std::exception& e) {
15609       {
15610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (...) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15615       };
15616     }
15617   }
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15626   Dali::Matrix3 *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Value *)jarg1;
15630   arg2 = (Dali::Matrix3 *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652   jresult = result;
15653   return jresult;
15654 }
15655
15656
15657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15658   unsigned int jresult ;
15659   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15660   Dali::Matrix *arg2 = 0 ;
15661   bool result;
15662
15663   arg1 = (Dali::Property::Value *)jarg1;
15664   arg2 = (Dali::Matrix *)jarg2;
15665   if (!arg2) {
15666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15667     return 0;
15668   }
15669   {
15670     try {
15671       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15683       };
15684     }
15685   }
15686   jresult = result;
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15694   Dali::AngleAxis *arg2 = 0 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Value *)jarg1;
15698   arg2 = (Dali::AngleAxis *)jarg2;
15699   if (!arg2) {
15700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15701     return 0;
15702   }
15703   {
15704     try {
15705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15706     } catch (std::out_of_range& e) {
15707       {
15708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (std::exception& e) {
15711       {
15712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (...) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15717       };
15718     }
15719   }
15720   jresult = result;
15721   return jresult;
15722 }
15723
15724
15725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15726   unsigned int jresult ;
15727   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15728   Dali::Quaternion *arg2 = 0 ;
15729   bool result;
15730
15731   arg1 = (Dali::Property::Value *)jarg1;
15732   arg2 = (Dali::Quaternion *)jarg2;
15733   if (!arg2) {
15734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15735     return 0;
15736   }
15737   {
15738     try {
15739       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15740     } catch (std::out_of_range& e) {
15741       {
15742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15743       };
15744     } catch (std::exception& e) {
15745       {
15746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (...) {
15749       {
15750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15751       };
15752     }
15753   }
15754   jresult = result;
15755   return jresult;
15756 }
15757
15758
15759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15760   unsigned int jresult ;
15761   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15762   std::string *arg2 = 0 ;
15763   bool result;
15764
15765   arg1 = (Dali::Property::Value *)jarg1;
15766
15767   //typemap in
15768   std::string temp;
15769   arg2 = &temp;
15770
15771   {
15772     try {
15773       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15774     } catch (std::out_of_range& e) {
15775       {
15776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15777       };
15778     } catch (std::exception& e) {
15779       {
15780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15781       };
15782     } catch (...) {
15783       {
15784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15785       };
15786     }
15787   }
15788   jresult = result;
15789
15790   //Typemap argout in c++ file.
15791   //This will convert c++ string to c# string
15792   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15793
15794   return jresult;
15795 }
15796
15797
15798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15799   unsigned int jresult ;
15800   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15801   Dali::Property::Array *arg2 = 0 ;
15802   bool result;
15803
15804   arg1 = (Dali::Property::Value *)jarg1;
15805   arg2 = (Dali::Property::Array *)jarg2;
15806   if (!arg2) {
15807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15808     return 0;
15809   }
15810   {
15811     try {
15812       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15813     } catch (std::out_of_range& e) {
15814       {
15815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (std::exception& e) {
15818       {
15819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827   jresult = result;
15828   return jresult;
15829 }
15830
15831
15832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15833   unsigned int jresult ;
15834   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15835   Dali::Property::Map *arg2 = 0 ;
15836   bool result;
15837
15838   arg1 = (Dali::Property::Value *)jarg1;
15839   arg2 = (Dali::Property::Map *)jarg2;
15840   if (!arg2) {
15841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15842     return 0;
15843   }
15844   {
15845     try {
15846       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15847     } catch (std::out_of_range& e) {
15848       {
15849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15850       };
15851     } catch (std::exception& e) {
15852       {
15853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (...) {
15856       {
15857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15858       };
15859     }
15860   }
15861   jresult = result;
15862   return jresult;
15863 }
15864
15865
15866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15867   void * jresult ;
15868   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15869   Dali::Property::Array *result = 0 ;
15870
15871   arg1 = (Dali::Property::Value *)jarg1;
15872   {
15873     try {
15874       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15875     } catch (std::out_of_range& e) {
15876       {
15877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15878       };
15879     } catch (std::exception& e) {
15880       {
15881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15882       };
15883     } catch (...) {
15884       {
15885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15886       };
15887     }
15888   }
15889   jresult = (void *)result;
15890   return jresult;
15891 }
15892
15893
15894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15895   void * jresult ;
15896   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15897   Dali::Property::Map *result = 0 ;
15898
15899   arg1 = (Dali::Property::Value *)jarg1;
15900   {
15901     try {
15902       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
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 = (void *)result;
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15923   char * jresult ;
15924   Dali::Property::Type arg1 ;
15925   char *result = 0 ;
15926
15927   arg1 = (Dali::Property::Type)jarg1;
15928   {
15929     try {
15930       result = (char *)Dali::PropertyTypes::GetName(arg1);
15931     } catch (std::out_of_range& e) {
15932       {
15933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15934       };
15935     } catch (std::exception& e) {
15936       {
15937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15938       };
15939     } catch (...) {
15940       {
15941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15942       };
15943     }
15944   }
15945   jresult = SWIG_csharp_string_callback((const char *)result);
15946   return jresult;
15947 }
15948
15949
15950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15951   unsigned int jresult ;
15952   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15953   std::string *arg2 = 0 ;
15954   Dali::Property::Map *arg3 = 0 ;
15955   bool result;
15956
15957   arg1 = (Dali::BaseObject *)jarg1;
15958   if (!jarg2) {
15959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15960     return 0;
15961   }
15962   std::string arg2_str(jarg2);
15963   arg2 = &arg2_str;
15964   arg3 = (Dali::Property::Map *)jarg3;
15965   if (!arg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15967     return 0;
15968   }
15969   {
15970     try {
15971       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15972     } catch (std::out_of_range& e) {
15973       {
15974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15975       };
15976     } catch (std::exception& e) {
15977       {
15978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (...) {
15981       {
15982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15983       };
15984     }
15985   }
15986   jresult = result;
15987
15988   //argout typemap for const std::string&
15989
15990   return jresult;
15991 }
15992
15993
15994 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15995   char * jresult ;
15996   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15997   std::string *result = 0 ;
15998
15999   arg1 = (Dali::BaseObject *)jarg1;
16000   {
16001     try {
16002       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16003     } catch (std::out_of_range& e) {
16004       {
16005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16006       };
16007     } catch (std::exception& e) {
16008       {
16009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16010       };
16011     } catch (...) {
16012       {
16013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16014       };
16015     }
16016   }
16017   jresult = SWIG_csharp_string_callback(result->c_str());
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16023   unsigned int jresult ;
16024   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16025   Dali::TypeInfo *arg2 = 0 ;
16026   bool result;
16027
16028   arg1 = (Dali::BaseObject *)jarg1;
16029   arg2 = (Dali::TypeInfo *)jarg2;
16030   if (!arg2) {
16031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16032     return 0;
16033   }
16034   {
16035     try {
16036       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16037     } catch (std::out_of_range& e) {
16038       {
16039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16040       };
16041     } catch (std::exception& e) {
16042       {
16043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16044       };
16045     } catch (...) {
16046       {
16047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16048       };
16049     }
16050   }
16051   jresult = result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16057   unsigned int jresult ;
16058   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16059   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16060   std::string *arg3 = 0 ;
16061   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16062   bool result;
16063
16064   arg1 = (Dali::BaseObject *)jarg1;
16065   arg2 = (ConnectionTrackerInterface *)jarg2;
16066   if (!jarg3) {
16067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16068     return 0;
16069   }
16070   std::string arg3_str(jarg3);
16071   arg3 = &arg3_str;
16072   arg4 = (FunctorDelegate *)jarg4;
16073   {
16074     try {
16075       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16076     } catch (std::out_of_range& e) {
16077       {
16078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16079       };
16080     } catch (std::exception& e) {
16081       {
16082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16083       };
16084     } catch (...) {
16085       {
16086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16087       };
16088     }
16089   }
16090   jresult = result;
16091
16092   //argout typemap for const std::string&
16093
16094   return jresult;
16095 }
16096
16097
16098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16099   void * jresult ;
16100   Dali::BaseHandle *arg1 = 0 ;
16101   Dali::BaseObject *result = 0 ;
16102
16103   arg1 = (Dali::BaseHandle *)jarg1;
16104   if (!arg1) {
16105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16106     return 0;
16107   }
16108   {
16109     try {
16110       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16111     } catch (std::out_of_range& e) {
16112       {
16113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16114       };
16115     } catch (std::exception& e) {
16116       {
16117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16118       };
16119     } catch (...) {
16120       {
16121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16122       };
16123     }
16124   }
16125   jresult = (void *)result;
16126   return jresult;
16127 }
16128
16129
16130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16131   void * jresult ;
16132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16133   Dali::BaseHandle *result = 0 ;
16134
16135   arg1 = (Dali::BaseObject *)jarg1;
16136   {
16137     try {
16138       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16139     } catch (std::out_of_range& e) {
16140       {
16141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (std::exception& e) {
16144       {
16145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16159   void * jresult ;
16160   Dali::BaseHandle *result = 0 ;
16161
16162   {
16163     try {
16164       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16165     } catch (std::out_of_range& e) {
16166       {
16167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16168       };
16169     } catch (std::exception& e) {
16170       {
16171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16172       };
16173     } catch (...) {
16174       {
16175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16176       };
16177     }
16178   }
16179   jresult = (void *)result;
16180   return jresult;
16181 }
16182
16183
16184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16185   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16186
16187   arg1 = (Dali::BaseHandle *)jarg1;
16188   {
16189     try {
16190       delete arg1;
16191     } catch (std::out_of_range& e) {
16192       {
16193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16194       };
16195     } catch (std::exception& e) {
16196       {
16197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16198       };
16199     } catch (...) {
16200       {
16201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16202       };
16203     }
16204   }
16205 }
16206
16207
16208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16209   void * jresult ;
16210   Dali::BaseHandle *arg1 = 0 ;
16211   Dali::BaseHandle *result = 0 ;
16212
16213   arg1 = (Dali::BaseHandle *)jarg1;
16214   if (!arg1) {
16215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16216     return 0;
16217   }
16218   {
16219     try {
16220       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16221     } catch (std::out_of_range& e) {
16222       {
16223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (std::exception& e) {
16226       {
16227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (...) {
16230       {
16231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16232       };
16233     }
16234   }
16235   jresult = (void *)result;
16236   return jresult;
16237 }
16238
16239
16240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16241   void * jresult ;
16242   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16243   Dali::BaseHandle *arg2 = 0 ;
16244   Dali::BaseHandle *result = 0 ;
16245
16246   arg1 = (Dali::BaseHandle *)jarg1;
16247   arg2 = (Dali::BaseHandle *)jarg2;
16248   if (!arg2) {
16249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16250     return 0;
16251   }
16252   {
16253     try {
16254       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16255     } catch (std::out_of_range& e) {
16256       {
16257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16258       };
16259     } catch (std::exception& e) {
16260       {
16261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16262       };
16263     } catch (...) {
16264       {
16265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16266       };
16267     }
16268   }
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16275   unsigned int jresult ;
16276   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16277   std::string *arg2 = 0 ;
16278   Dali::Property::Map *arg3 = 0 ;
16279   bool result;
16280
16281   arg1 = (Dali::BaseHandle *)jarg1;
16282   if (!jarg2) {
16283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16284     return 0;
16285   }
16286   std::string arg2_str(jarg2);
16287   arg2 = &arg2_str;
16288   arg3 = (Dali::Property::Map *)jarg3;
16289   if (!arg3) {
16290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16291     return 0;
16292   }
16293   {
16294     try {
16295       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16296     } catch (std::out_of_range& e) {
16297       {
16298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16299       };
16300     } catch (std::exception& e) {
16301       {
16302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16303       };
16304     } catch (...) {
16305       {
16306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16307       };
16308     }
16309   }
16310   jresult = result;
16311
16312   //argout typemap for const std::string&
16313
16314   return jresult;
16315 }
16316
16317
16318 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16319   char * jresult ;
16320   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16321   std::string *result = 0 ;
16322
16323   arg1 = (Dali::BaseHandle *)jarg1;
16324   {
16325     try {
16326       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16327     } catch (std::out_of_range& e) {
16328       {
16329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16330       };
16331     } catch (std::exception& e) {
16332       {
16333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16334       };
16335     } catch (...) {
16336       {
16337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16338       };
16339     }
16340   }
16341   jresult = SWIG_csharp_string_callback(result->c_str());
16342   return jresult;
16343 }
16344
16345
16346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16347   unsigned int jresult ;
16348   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16349   Dali::TypeInfo *arg2 = 0 ;
16350   bool result;
16351
16352   arg1 = (Dali::BaseHandle *)jarg1;
16353   arg2 = (Dali::TypeInfo *)jarg2;
16354   if (!arg2) {
16355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16356     return 0;
16357   }
16358   {
16359     try {
16360       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16361     } catch (std::out_of_range& e) {
16362       {
16363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (std::exception& e) {
16366       {
16367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375   jresult = result;
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16381   void * jresult ;
16382   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16383   Dali::BaseObject *result = 0 ;
16384
16385   arg1 = (Dali::BaseHandle *)jarg1;
16386   {
16387     try {
16388       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16389     } catch (std::out_of_range& e) {
16390       {
16391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16392       };
16393     } catch (std::exception& e) {
16394       {
16395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (...) {
16398       {
16399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16400       };
16401     }
16402   }
16403   jresult = (void *)result;
16404   return jresult;
16405 }
16406
16407
16408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16409   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16410
16411   arg1 = (Dali::BaseHandle *)jarg1;
16412   {
16413     try {
16414       (arg1)->Reset();
16415     } catch (std::out_of_range& e) {
16416       {
16417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16418       };
16419     } catch (std::exception& e) {
16420       {
16421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16422       };
16423     } catch (...) {
16424       {
16425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16426       };
16427     }
16428   }
16429 }
16430
16431
16432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16433   unsigned int jresult ;
16434   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16435   Dali::BaseHandle *arg2 = 0 ;
16436   bool result;
16437
16438   arg1 = (Dali::BaseHandle *)jarg1;
16439   arg2 = (Dali::BaseHandle *)jarg2;
16440   if (!arg2) {
16441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16442     return 0;
16443   }
16444   {
16445     try {
16446       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16447     } catch (std::out_of_range& e) {
16448       {
16449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (std::exception& e) {
16452       {
16453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (...) {
16456       {
16457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16458       };
16459     }
16460   }
16461   jresult = result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16467   unsigned int jresult ;
16468   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16469   Dali::BaseHandle *arg2 = 0 ;
16470   bool result;
16471
16472   arg1 = (Dali::BaseHandle *)jarg1;
16473   arg2 = (Dali::BaseHandle *)jarg2;
16474   if (!arg2) {
16475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16476     return 0;
16477   }
16478   {
16479     try {
16480       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16481     } catch (std::out_of_range& e) {
16482       {
16483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16484       };
16485     } catch (std::exception& e) {
16486       {
16487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (...) {
16490       {
16491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16492       };
16493     }
16494   }
16495   jresult = result;
16496   return jresult;
16497 }
16498
16499
16500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16501   void * jresult ;
16502   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16503   Dali::RefObject *result = 0 ;
16504
16505   arg1 = (Dali::BaseHandle *)jarg1;
16506   {
16507     try {
16508       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
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 = (void *)result;
16524   return jresult;
16525 }
16526
16527
16528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16529   unsigned int jresult ;
16530   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16531   bool result;
16532
16533   arg1 = (Dali::BaseHandle *)jarg1;
16534   {
16535     try {
16536       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16537     } catch (std::out_of_range& e) {
16538       {
16539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (std::exception& e) {
16542       {
16543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16544       };
16545     } catch (...) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16548       };
16549     }
16550   }
16551   jresult = result;
16552   return jresult;
16553 }
16554
16555
16556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16557   unsigned int jresult ;
16558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16559   Dali::BaseHandle *arg2 = 0 ;
16560   bool result;
16561
16562   arg1 = (Dali::BaseHandle *)jarg1;
16563   arg2 = (Dali::BaseHandle *)jarg2;
16564   if (!arg2) {
16565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16566     return 0;
16567   }
16568   {
16569     try {
16570       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (...) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16582       };
16583     }
16584   }
16585   jresult = result;
16586   return jresult;
16587 }
16588
16589
16590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16591   unsigned int jresult ;
16592   Dali::BaseHandle *arg1 = 0 ;
16593   Dali::BaseHandle *arg2 = 0 ;
16594   bool result;
16595
16596   arg1 = (Dali::BaseHandle *)jarg1;
16597   if (!arg1) {
16598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16599     return 0;
16600   }
16601   arg2 = (Dali::BaseHandle *)jarg2;
16602   if (!arg2) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16604     return 0;
16605   }
16606   {
16607     try {
16608       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16609     } catch (std::out_of_range& e) {
16610       {
16611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16612       };
16613     } catch (std::exception& e) {
16614       {
16615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16616       };
16617     } catch (...) {
16618       {
16619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16620       };
16621     }
16622   }
16623   jresult = result;
16624   return jresult;
16625 }
16626
16627
16628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16629   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16630
16631   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16632   {
16633     try {
16634       delete arg1;
16635     } catch (std::out_of_range& e) {
16636       {
16637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16638       };
16639     } catch (std::exception& e) {
16640       {
16641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (...) {
16644       {
16645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16646       };
16647     }
16648   }
16649 }
16650
16651
16652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16653   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16654   SlotObserver *arg2 = (SlotObserver *) 0 ;
16655   CallbackBase *arg3 = (CallbackBase *) 0 ;
16656
16657   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16658   arg2 = (SlotObserver *)jarg2;
16659   arg3 = (CallbackBase *)jarg3;
16660   {
16661     try {
16662       (arg1)->SignalConnected(arg2,arg3);
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (...) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16674       };
16675     }
16676   }
16677 }
16678
16679
16680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16681   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16682
16683   arg1 = (Dali::SignalObserver *)jarg1;
16684   {
16685     try {
16686       delete arg1;
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16694       };
16695     } catch (...) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16698       };
16699     }
16700   }
16701 }
16702
16703
16704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16705   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16706   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16707   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16708
16709   arg1 = (Dali::SignalObserver *)jarg1;
16710   arg2 = (Dali::SlotObserver *)jarg2;
16711   arg3 = (Dali::CallbackBase *)jarg3;
16712   {
16713     try {
16714       (arg1)->SignalDisconnected(arg2,arg3);
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (...) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16726       };
16727     }
16728   }
16729 }
16730
16731
16732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16733   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16734
16735   arg1 = (Dali::SlotObserver *)jarg1;
16736   {
16737     try {
16738       delete arg1;
16739     } catch (std::out_of_range& e) {
16740       {
16741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16742       };
16743     } catch (std::exception& e) {
16744       {
16745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16746       };
16747     } catch (...) {
16748       {
16749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16750       };
16751     }
16752   }
16753 }
16754
16755
16756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16757   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16758   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16759
16760   arg1 = (Dali::SlotObserver *)jarg1;
16761   arg2 = (Dali::CallbackBase *)jarg2;
16762   {
16763     try {
16764       (arg1)->SlotDisconnected(arg2);
16765     } catch (std::out_of_range& e) {
16766       {
16767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16768       };
16769     } catch (std::exception& e) {
16770       {
16771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (...) {
16774       {
16775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16776       };
16777     }
16778   }
16779 }
16780
16781
16782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16783   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16784
16785   arg1 = (Dali::ConnectionTracker *)jarg1;
16786   {
16787     try {
16788       delete arg1;
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16800       };
16801     }
16802   }
16803 }
16804
16805
16806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16807   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16808
16809   arg1 = (Dali::ConnectionTracker *)jarg1;
16810   {
16811     try {
16812       (arg1)->DisconnectAll();
16813     } catch (std::out_of_range& e) {
16814       {
16815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16816       };
16817     } catch (std::exception& e) {
16818       {
16819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16820       };
16821     } catch (...) {
16822       {
16823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16824       };
16825     }
16826   }
16827 }
16828
16829
16830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16831   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16832   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16833   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16834
16835   arg1 = (Dali::ConnectionTracker *)jarg1;
16836   arg2 = (Dali::SlotObserver *)jarg2;
16837   arg3 = (Dali::CallbackBase *)jarg3;
16838   {
16839     try {
16840       (arg1)->SignalConnected(arg2,arg3);
16841     } catch (std::out_of_range& e) {
16842       {
16843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16844       };
16845     } catch (std::exception& e) {
16846       {
16847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16848       };
16849     } catch (...) {
16850       {
16851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16852       };
16853     }
16854   }
16855 }
16856
16857
16858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16859   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16860   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16861   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16862
16863   arg1 = (Dali::ConnectionTracker *)jarg1;
16864   arg2 = (Dali::SlotObserver *)jarg2;
16865   arg3 = (Dali::CallbackBase *)jarg3;
16866   {
16867     try {
16868       (arg1)->SignalDisconnected(arg2,arg3);
16869     } catch (std::out_of_range& e) {
16870       {
16871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16872       };
16873     } catch (std::exception& e) {
16874       {
16875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16876       };
16877     } catch (...) {
16878       {
16879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16880       };
16881     }
16882   }
16883 }
16884
16885
16886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16887   unsigned long jresult ;
16888   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16889   std::size_t result;
16890
16891   arg1 = (Dali::ConnectionTracker *)jarg1;
16892   {
16893     try {
16894       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (...) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16906       };
16907     }
16908   }
16909   jresult = (unsigned long)result;
16910   return jresult;
16911 }
16912
16913
16914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16915   void * jresult ;
16916   Dali::ObjectRegistry *result = 0 ;
16917
16918   {
16919     try {
16920       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16921     } catch (std::out_of_range& e) {
16922       {
16923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (std::exception& e) {
16926       {
16927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16928       };
16929     } catch (...) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16932       };
16933     }
16934   }
16935   jresult = (void *)result;
16936   return jresult;
16937 }
16938
16939
16940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16941   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16942
16943   arg1 = (Dali::ObjectRegistry *)jarg1;
16944   {
16945     try {
16946       delete arg1;
16947     } catch (std::out_of_range& e) {
16948       {
16949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16950       };
16951     } catch (std::exception& e) {
16952       {
16953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16954       };
16955     } catch (...) {
16956       {
16957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16958       };
16959     }
16960   }
16961 }
16962
16963
16964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16965   void * jresult ;
16966   Dali::ObjectRegistry *arg1 = 0 ;
16967   Dali::ObjectRegistry *result = 0 ;
16968
16969   arg1 = (Dali::ObjectRegistry *)jarg1;
16970   if (!arg1) {
16971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16972     return 0;
16973   }
16974   {
16975     try {
16976       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16977     } catch (std::out_of_range& e) {
16978       {
16979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (std::exception& e) {
16982       {
16983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16997   void * jresult ;
16998   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16999   Dali::ObjectRegistry *arg2 = 0 ;
17000   Dali::ObjectRegistry *result = 0 ;
17001
17002   arg1 = (Dali::ObjectRegistry *)jarg1;
17003   arg2 = (Dali::ObjectRegistry *)jarg2;
17004   if (!arg2) {
17005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17006     return 0;
17007   }
17008   {
17009     try {
17010       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17011     } catch (std::out_of_range& e) {
17012       {
17013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (std::exception& e) {
17016       {
17017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17031   void * jresult ;
17032   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17033   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17034
17035   arg1 = (Dali::ObjectRegistry *)jarg1;
17036   {
17037     try {
17038       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17039     } catch (std::out_of_range& e) {
17040       {
17041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17042       };
17043     } catch (std::exception& e) {
17044       {
17045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (...) {
17048       {
17049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17050       };
17051     }
17052   }
17053   jresult = (void *)result;
17054   return jresult;
17055 }
17056
17057
17058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17059   void * jresult ;
17060   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17061   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17062
17063   arg1 = (Dali::ObjectRegistry *)jarg1;
17064   {
17065     try {
17066       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081   jresult = (void *)result;
17082   return jresult;
17083 }
17084
17085
17086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17087   void * jresult ;
17088   Dali::PropertyCondition *result = 0 ;
17089
17090   {
17091     try {
17092       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17093     } catch (std::out_of_range& e) {
17094       {
17095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17096       };
17097     } catch (std::exception& e) {
17098       {
17099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17100       };
17101     } catch (...) {
17102       {
17103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17104       };
17105     }
17106   }
17107   jresult = (void *)result;
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17113   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17114
17115   arg1 = (Dali::PropertyCondition *)jarg1;
17116   {
17117     try {
17118       delete arg1;
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17126       };
17127     } catch (...) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17130       };
17131     }
17132   }
17133 }
17134
17135
17136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17137   void * jresult ;
17138   Dali::PropertyCondition *arg1 = 0 ;
17139   Dali::PropertyCondition *result = 0 ;
17140
17141   arg1 = (Dali::PropertyCondition *)jarg1;
17142   if (!arg1) {
17143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17144     return 0;
17145   }
17146   {
17147     try {
17148       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17149     } catch (std::out_of_range& e) {
17150       {
17151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (std::exception& e) {
17154       {
17155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17156       };
17157     } catch (...) {
17158       {
17159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17160       };
17161     }
17162   }
17163   jresult = (void *)result;
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17169   void * jresult ;
17170   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17171   Dali::PropertyCondition *arg2 = 0 ;
17172   Dali::PropertyCondition *result = 0 ;
17173
17174   arg1 = (Dali::PropertyCondition *)jarg1;
17175   arg2 = (Dali::PropertyCondition *)jarg2;
17176   if (!arg2) {
17177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17178     return 0;
17179   }
17180   {
17181     try {
17182       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17183     } catch (std::out_of_range& e) {
17184       {
17185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17186       };
17187     } catch (std::exception& e) {
17188       {
17189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (...) {
17192       {
17193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17194       };
17195     }
17196   }
17197   jresult = (void *)result;
17198   return jresult;
17199 }
17200
17201
17202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17203   unsigned long jresult ;
17204   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17205   std::size_t result;
17206
17207   arg1 = (Dali::PropertyCondition *)jarg1;
17208   {
17209     try {
17210       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17211     } catch (std::out_of_range& e) {
17212       {
17213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17214       };
17215     } catch (std::exception& e) {
17216       {
17217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (...) {
17220       {
17221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17222       };
17223     }
17224   }
17225   jresult = (unsigned long)result;
17226   return jresult;
17227 }
17228
17229
17230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17231   float jresult ;
17232   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17233   std::size_t arg2 ;
17234   float result;
17235
17236   arg1 = (Dali::PropertyCondition *)jarg1;
17237   arg2 = (std::size_t)jarg2;
17238   {
17239     try {
17240       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17241     } catch (std::out_of_range& e) {
17242       {
17243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17244       };
17245     } catch (std::exception& e) {
17246       {
17247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (...) {
17250       {
17251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17252       };
17253     }
17254   }
17255   jresult = result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17261   void * jresult ;
17262   float arg1 ;
17263   Dali::PropertyCondition result;
17264
17265   arg1 = (float)jarg1;
17266   {
17267     try {
17268       result = Dali::LessThanCondition(arg1);
17269     } catch (std::out_of_range& e) {
17270       {
17271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17272       };
17273     } catch (std::exception& e) {
17274       {
17275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (...) {
17278       {
17279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17280       };
17281     }
17282   }
17283   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17289   void * jresult ;
17290   float arg1 ;
17291   Dali::PropertyCondition result;
17292
17293   arg1 = (float)jarg1;
17294   {
17295     try {
17296       result = Dali::GreaterThanCondition(arg1);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (...) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17308       };
17309     }
17310   }
17311   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17312   return jresult;
17313 }
17314
17315
17316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17317   void * jresult ;
17318   float arg1 ;
17319   float arg2 ;
17320   Dali::PropertyCondition result;
17321
17322   arg1 = (float)jarg1;
17323   arg2 = (float)jarg2;
17324   {
17325     try {
17326       result = Dali::InsideCondition(arg1,arg2);
17327     } catch (std::out_of_range& e) {
17328       {
17329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (std::exception& e) {
17332       {
17333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17342   return jresult;
17343 }
17344
17345
17346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17347   void * jresult ;
17348   float arg1 ;
17349   float arg2 ;
17350   Dali::PropertyCondition result;
17351
17352   arg1 = (float)jarg1;
17353   arg2 = (float)jarg2;
17354   {
17355     try {
17356       result = Dali::OutsideCondition(arg1,arg2);
17357     } catch (std::out_of_range& e) {
17358       {
17359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17360       };
17361     } catch (std::exception& e) {
17362       {
17363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17364       };
17365     } catch (...) {
17366       {
17367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17368       };
17369     }
17370   }
17371   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17372   return jresult;
17373 }
17374
17375
17376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17377   void * jresult ;
17378   float arg1 ;
17379   float arg2 ;
17380   Dali::PropertyCondition result;
17381
17382   arg1 = (float)jarg1;
17383   arg2 = (float)jarg2;
17384   {
17385     try {
17386       result = Dali::StepCondition(arg1,arg2);
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (...) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17398       };
17399     }
17400   }
17401   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17402   return jresult;
17403 }
17404
17405
17406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17407   void * jresult ;
17408   float arg1 ;
17409   Dali::PropertyCondition result;
17410
17411   arg1 = (float)jarg1;
17412   {
17413     try {
17414       result = Dali::StepCondition(arg1);
17415     } catch (std::out_of_range& e) {
17416       {
17417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17418       };
17419     } catch (std::exception& e) {
17420       {
17421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17422       };
17423     } catch (...) {
17424       {
17425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17426       };
17427     }
17428   }
17429   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17430   return jresult;
17431 }
17432
17433
17434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17435   void * jresult ;
17436   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17437   Dali::PropertyCondition result;
17438
17439   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17440   if (!arg1) {
17441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17442     return 0;
17443   }
17444   {
17445     try {
17446       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17447     } catch (std::out_of_range& e) {
17448       {
17449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17450       };
17451     } catch (std::exception& e) {
17452       {
17453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17454       };
17455     } catch (...) {
17456       {
17457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17458       };
17459     }
17460   }
17461   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17462   return jresult;
17463 }
17464
17465
17466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17467   void * jresult ;
17468   Dali::PropertyNotification *result = 0 ;
17469
17470   {
17471     try {
17472       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17473     } catch (std::out_of_range& e) {
17474       {
17475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (std::exception& e) {
17478       {
17479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487   jresult = (void *)result;
17488   return jresult;
17489 }
17490
17491
17492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17493   void * jresult ;
17494   Dali::BaseHandle arg1 ;
17495   Dali::BaseHandle *argp1 ;
17496   Dali::PropertyNotification result;
17497
17498   argp1 = (Dali::BaseHandle *)jarg1;
17499   if (!argp1) {
17500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17501     return 0;
17502   }
17503   arg1 = *argp1;
17504   {
17505     try {
17506       result = Dali::PropertyNotification::DownCast(arg1);
17507     } catch (std::out_of_range& e) {
17508       {
17509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (std::exception& e) {
17512       {
17513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (...) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17518       };
17519     }
17520   }
17521   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17522   return jresult;
17523 }
17524
17525
17526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17527   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17528
17529   arg1 = (Dali::PropertyNotification *)jarg1;
17530   {
17531     try {
17532       delete arg1;
17533     } catch (std::out_of_range& e) {
17534       {
17535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17536       };
17537     } catch (std::exception& e) {
17538       {
17539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17544       };
17545     }
17546   }
17547 }
17548
17549
17550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17551   void * jresult ;
17552   Dali::PropertyNotification *arg1 = 0 ;
17553   Dali::PropertyNotification *result = 0 ;
17554
17555   arg1 = (Dali::PropertyNotification *)jarg1;
17556   if (!arg1) {
17557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17558     return 0;
17559   }
17560   {
17561     try {
17562       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17563     } catch (std::out_of_range& e) {
17564       {
17565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17566       };
17567     } catch (std::exception& e) {
17568       {
17569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17570       };
17571     } catch (...) {
17572       {
17573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17574       };
17575     }
17576   }
17577   jresult = (void *)result;
17578   return jresult;
17579 }
17580
17581
17582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17583   void * jresult ;
17584   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17585   Dali::PropertyNotification *arg2 = 0 ;
17586   Dali::PropertyNotification *result = 0 ;
17587
17588   arg1 = (Dali::PropertyNotification *)jarg1;
17589   arg2 = (Dali::PropertyNotification *)jarg2;
17590   if (!arg2) {
17591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17592     return 0;
17593   }
17594   {
17595     try {
17596       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17597     } catch (std::out_of_range& e) {
17598       {
17599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17600       };
17601     } catch (std::exception& e) {
17602       {
17603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (...) {
17606       {
17607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17608       };
17609     }
17610   }
17611   jresult = (void *)result;
17612   return jresult;
17613 }
17614
17615
17616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17617   void * jresult ;
17618   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17619   Dali::PropertyCondition result;
17620
17621   arg1 = (Dali::PropertyNotification *)jarg1;
17622   {
17623     try {
17624       result = (arg1)->GetCondition();
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (...) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17636       };
17637     }
17638   }
17639   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17645   void * jresult ;
17646   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17647   Dali::Handle result;
17648
17649   arg1 = (Dali::PropertyNotification *)jarg1;
17650   {
17651     try {
17652       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17653     } catch (std::out_of_range& e) {
17654       {
17655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17656       };
17657     } catch (std::exception& e) {
17658       {
17659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17660       };
17661     } catch (...) {
17662       {
17663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17664       };
17665     }
17666   }
17667   jresult = new Dali::Handle((const Dali::Handle &)result);
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17673   int jresult ;
17674   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17675   Dali::Property::Index result;
17676
17677   arg1 = (Dali::PropertyNotification *)jarg1;
17678   {
17679     try {
17680       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17681     } catch (std::out_of_range& e) {
17682       {
17683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (std::exception& e) {
17686       {
17687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (...) {
17690       {
17691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17692       };
17693     }
17694   }
17695   jresult = result;
17696   return jresult;
17697 }
17698
17699
17700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17701   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17702   Dali::PropertyNotification::NotifyMode arg2 ;
17703
17704   arg1 = (Dali::PropertyNotification *)jarg1;
17705   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17706   {
17707     try {
17708       (arg1)->SetNotifyMode(arg2);
17709     } catch (std::out_of_range& e) {
17710       {
17711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17712       };
17713     } catch (std::exception& e) {
17714       {
17715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17716       };
17717     } catch (...) {
17718       {
17719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17720       };
17721     }
17722   }
17723 }
17724
17725
17726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17727   int jresult ;
17728   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17729   Dali::PropertyNotification::NotifyMode result;
17730
17731   arg1 = (Dali::PropertyNotification *)jarg1;
17732   {
17733     try {
17734       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17735     } catch (std::out_of_range& e) {
17736       {
17737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17738       };
17739     } catch (std::exception& e) {
17740       {
17741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (...) {
17744       {
17745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17746       };
17747     }
17748   }
17749   jresult = (int)result;
17750   return jresult;
17751 }
17752
17753
17754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17755   unsigned int jresult ;
17756   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17757   bool result;
17758
17759   arg1 = (Dali::PropertyNotification *)jarg1;
17760   {
17761     try {
17762       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (...) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17774       };
17775     }
17776   }
17777   jresult = result;
17778   return jresult;
17779 }
17780
17781
17782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17783   void * jresult ;
17784   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17785   Dali::PropertyNotifySignalType *result = 0 ;
17786
17787   arg1 = (Dali::PropertyNotification *)jarg1;
17788   {
17789     try {
17790       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17791     } catch (std::out_of_range& e) {
17792       {
17793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17794       };
17795     } catch (std::exception& e) {
17796       {
17797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17798       };
17799     } catch (...) {
17800       {
17801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17802       };
17803     }
17804   }
17805   jresult = (void *)result;
17806   return jresult;
17807 }
17808
17809
17810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17811   void * jresult ;
17812   Dali::Handle *result = 0 ;
17813
17814   {
17815     try {
17816       result = (Dali::Handle *)new Dali::Handle();
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (...) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17828       };
17829     }
17830   }
17831   jresult = (void *)result;
17832   return jresult;
17833 }
17834
17835
17836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17837   void * jresult ;
17838   Dali::Handle result;
17839
17840   {
17841     try {
17842       result = Dali::Handle::New();
17843     } catch (std::out_of_range& e) {
17844       {
17845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (std::exception& e) {
17848       {
17849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17850       };
17851     } catch (...) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17854       };
17855     }
17856   }
17857   jresult = new Dali::Handle((const Dali::Handle &)result);
17858   return jresult;
17859 }
17860
17861
17862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17863   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17864
17865   arg1 = (Dali::Handle *)jarg1;
17866   {
17867     try {
17868       delete arg1;
17869     } catch (std::out_of_range& e) {
17870       {
17871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17872       };
17873     } catch (std::exception& e) {
17874       {
17875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17880       };
17881     }
17882   }
17883 }
17884
17885
17886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17887   void * jresult ;
17888   Dali::Handle *arg1 = 0 ;
17889   Dali::Handle *result = 0 ;
17890
17891   arg1 = (Dali::Handle *)jarg1;
17892   if (!arg1) {
17893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17894     return 0;
17895   }
17896   {
17897     try {
17898       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17899     } catch (std::out_of_range& e) {
17900       {
17901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (std::exception& e) {
17904       {
17905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (...) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17910       };
17911     }
17912   }
17913   jresult = (void *)result;
17914   return jresult;
17915 }
17916
17917
17918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17919   void * jresult ;
17920   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17921   Dali::Handle *arg2 = 0 ;
17922   Dali::Handle *result = 0 ;
17923
17924   arg1 = (Dali::Handle *)jarg1;
17925   arg2 = (Dali::Handle *)jarg2;
17926   if (!arg2) {
17927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17928     return 0;
17929   }
17930   {
17931     try {
17932       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17933     } catch (std::out_of_range& e) {
17934       {
17935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17936       };
17937     } catch (std::exception& e) {
17938       {
17939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (...) {
17942       {
17943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17944       };
17945     }
17946   }
17947   jresult = (void *)result;
17948   return jresult;
17949 }
17950
17951
17952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17953   void * jresult ;
17954   Dali::BaseHandle arg1 ;
17955   Dali::BaseHandle *argp1 ;
17956   Dali::Handle result;
17957
17958   argp1 = (Dali::BaseHandle *)jarg1;
17959   if (!argp1) {
17960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17961     return 0;
17962   }
17963   arg1 = *argp1;
17964   {
17965     try {
17966       result = Dali::Handle::DownCast(arg1);
17967     } catch (std::out_of_range& e) {
17968       {
17969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (std::exception& e) {
17972       {
17973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (...) {
17976       {
17977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17978       };
17979     }
17980   }
17981   jresult = new Dali::Handle((const Dali::Handle &)result);
17982   return jresult;
17983 }
17984
17985
17986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17987   unsigned int jresult ;
17988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17989   Dali::Handle::Capability arg2 ;
17990   bool result;
17991
17992   arg1 = (Dali::Handle *)jarg1;
17993   arg2 = (Dali::Handle::Capability)jarg2;
17994   {
17995     try {
17996       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17997     } catch (std::out_of_range& e) {
17998       {
17999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18000       };
18001     } catch (std::exception& e) {
18002       {
18003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (...) {
18006       {
18007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18008       };
18009     }
18010   }
18011   jresult = result;
18012   return jresult;
18013 }
18014
18015
18016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18017   unsigned int jresult ;
18018   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18019   unsigned int result;
18020
18021   arg1 = (Dali::Handle *)jarg1;
18022   {
18023     try {
18024       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18025     } catch (std::out_of_range& e) {
18026       {
18027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18028       };
18029     } catch (std::exception& e) {
18030       {
18031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18032       };
18033     } catch (...) {
18034       {
18035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18036       };
18037     }
18038   }
18039   jresult = result;
18040   return jresult;
18041 }
18042
18043
18044 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18045   char * jresult ;
18046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18047   Dali::Property::Index arg2 ;
18048   std::string result;
18049
18050   arg1 = (Dali::Handle *)jarg1;
18051   arg2 = (Dali::Property::Index)jarg2;
18052   {
18053     try {
18054       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18055     } catch (std::out_of_range& e) {
18056       {
18057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18058       };
18059     } catch (std::exception& e) {
18060       {
18061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (...) {
18064       {
18065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18066       };
18067     }
18068   }
18069   jresult = SWIG_csharp_string_callback((&result)->c_str());
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18075   int jresult ;
18076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18077   std::string *arg2 = 0 ;
18078   Dali::Property::Index result;
18079
18080   arg1 = (Dali::Handle *)jarg1;
18081   if (!jarg2) {
18082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18083     return 0;
18084   }
18085   std::string arg2_str(jarg2);
18086   arg2 = &arg2_str;
18087   {
18088     try {
18089       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18090     } catch (std::out_of_range& e) {
18091       {
18092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18093       };
18094     } catch (std::exception& e) {
18095       {
18096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (...) {
18099       {
18100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18101       };
18102     }
18103   }
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18113   unsigned int jresult ;
18114   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18115   Dali::Property::Index arg2 ;
18116   bool result;
18117
18118   arg1 = (Dali::Handle *)jarg1;
18119   arg2 = (Dali::Property::Index)jarg2;
18120   {
18121     try {
18122       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18123     } catch (std::out_of_range& e) {
18124       {
18125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (std::exception& e) {
18128       {
18129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137   jresult = result;
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18143   unsigned int jresult ;
18144   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18145   Dali::Property::Index arg2 ;
18146   bool result;
18147
18148   arg1 = (Dali::Handle *)jarg1;
18149   arg2 = (Dali::Property::Index)jarg2;
18150   {
18151     try {
18152       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18153     } catch (std::out_of_range& e) {
18154       {
18155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18156       };
18157     } catch (std::exception& e) {
18158       {
18159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (...) {
18162       {
18163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18164       };
18165     }
18166   }
18167   jresult = result;
18168   return jresult;
18169 }
18170
18171
18172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18173   unsigned int jresult ;
18174   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18175   Dali::Property::Index arg2 ;
18176   bool result;
18177
18178   arg1 = (Dali::Handle *)jarg1;
18179   arg2 = (Dali::Property::Index)jarg2;
18180   {
18181     try {
18182       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18183     } catch (std::out_of_range& e) {
18184       {
18185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18186       };
18187     } catch (std::exception& e) {
18188       {
18189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18190       };
18191     } catch (...) {
18192       {
18193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18194       };
18195     }
18196   }
18197   jresult = result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18203   int jresult ;
18204   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18205   Dali::Property::Index arg2 ;
18206   Dali::Property::Type result;
18207
18208   arg1 = (Dali::Handle *)jarg1;
18209   arg2 = (Dali::Property::Index)jarg2;
18210   {
18211     try {
18212       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18213     } catch (std::out_of_range& e) {
18214       {
18215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18216       };
18217     } catch (std::exception& e) {
18218       {
18219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18220       };
18221     } catch (...) {
18222       {
18223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18224       };
18225     }
18226   }
18227   jresult = (int)result;
18228   return jresult;
18229 }
18230
18231
18232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18233   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18234   Dali::Property::Index arg2 ;
18235   Dali::Property::Value *arg3 = 0 ;
18236
18237   arg1 = (Dali::Handle *)jarg1;
18238   arg2 = (Dali::Property::Index)jarg2;
18239   arg3 = (Dali::Property::Value *)jarg3;
18240   if (!arg3) {
18241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18242     return ;
18243   }
18244   {
18245     try {
18246       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18247     } catch (std::out_of_range& e) {
18248       {
18249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18250       };
18251     } catch (std::exception& e) {
18252       {
18253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18254       };
18255     } catch (...) {
18256       {
18257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18258       };
18259     }
18260   }
18261 }
18262
18263
18264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18265   int jresult ;
18266   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18267   std::string *arg2 = 0 ;
18268   Dali::Property::Value *arg3 = 0 ;
18269   Dali::Property::Index result;
18270
18271   arg1 = (Dali::Handle *)jarg1;
18272   if (!jarg2) {
18273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18274     return 0;
18275   }
18276   std::string arg2_str(jarg2);
18277   arg2 = &arg2_str;
18278   arg3 = (Dali::Property::Value *)jarg3;
18279   if (!arg3) {
18280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18281     return 0;
18282   }
18283   {
18284     try {
18285       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18286     } catch (std::out_of_range& e) {
18287       {
18288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18289       };
18290     } catch (std::exception& e) {
18291       {
18292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18293       };
18294     } catch (...) {
18295       {
18296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18297       };
18298     }
18299   }
18300   jresult = result;
18301
18302   //argout typemap for const std::string&
18303
18304   return jresult;
18305 }
18306
18307
18308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18309   int jresult ;
18310   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18311   std::string *arg2 = 0 ;
18312   Dali::Property::Value *arg3 = 0 ;
18313   Dali::Property::AccessMode arg4 ;
18314   Dali::Property::Index result;
18315
18316   arg1 = (Dali::Handle *)jarg1;
18317   if (!jarg2) {
18318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18319     return 0;
18320   }
18321   std::string arg2_str(jarg2);
18322   arg2 = &arg2_str;
18323   arg3 = (Dali::Property::Value *)jarg3;
18324   if (!arg3) {
18325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18326     return 0;
18327   }
18328   arg4 = (Dali::Property::AccessMode)jarg4;
18329   {
18330     try {
18331       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18332     } catch (std::out_of_range& e) {
18333       {
18334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (std::exception& e) {
18337       {
18338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346   jresult = result;
18347
18348   //argout typemap for const std::string&
18349
18350   return jresult;
18351 }
18352
18353
18354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18355   void * jresult ;
18356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18357   Dali::Property::Index arg2 ;
18358   Dali::Property::Value result;
18359
18360   arg1 = (Dali::Handle *)jarg1;
18361   arg2 = (Dali::Property::Index)jarg2;
18362   {
18363     try {
18364       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18365     } catch (std::out_of_range& e) {
18366       {
18367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18368       };
18369     } catch (std::exception& e) {
18370       {
18371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (...) {
18374       {
18375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18376       };
18377     }
18378   }
18379   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18380   return jresult;
18381 }
18382
18383
18384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18385   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18386   Dali::Property::IndexContainer *arg2 = 0 ;
18387
18388   arg1 = (Dali::Handle *)jarg1;
18389   arg2 = (Dali::Property::IndexContainer *)jarg2;
18390   if (!arg2) {
18391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18392     return ;
18393   }
18394   {
18395     try {
18396       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18397     } catch (std::out_of_range& e) {
18398       {
18399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18400       };
18401     } catch (std::exception& e) {
18402       {
18403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18408       };
18409     }
18410   }
18411 }
18412
18413
18414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18415   void * jresult ;
18416   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18417   Dali::Property::Index arg2 ;
18418   Dali::PropertyCondition *arg3 = 0 ;
18419   Dali::PropertyNotification result;
18420
18421   arg1 = (Dali::Handle *)jarg1;
18422   arg2 = (Dali::Property::Index)jarg2;
18423   arg3 = (Dali::PropertyCondition *)jarg3;
18424   if (!arg3) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (...) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18442       };
18443     }
18444   }
18445   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18446   return jresult;
18447 }
18448
18449
18450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18451   void * jresult ;
18452   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18453   Dali::Property::Index arg2 ;
18454   int arg3 ;
18455   Dali::PropertyCondition *arg4 = 0 ;
18456   Dali::PropertyNotification result;
18457
18458   arg1 = (Dali::Handle *)jarg1;
18459   arg2 = (Dali::Property::Index)jarg2;
18460   arg3 = (int)jarg3;
18461   arg4 = (Dali::PropertyCondition *)jarg4;
18462   if (!arg4) {
18463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18464     return 0;
18465   }
18466   {
18467     try {
18468       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18469     } catch (std::out_of_range& e) {
18470       {
18471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18472       };
18473     } catch (std::exception& e) {
18474       {
18475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18476       };
18477     } catch (...) {
18478       {
18479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18480       };
18481     }
18482   }
18483   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18484   return jresult;
18485 }
18486
18487
18488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18490   Dali::PropertyNotification arg2 ;
18491   Dali::PropertyNotification *argp2 ;
18492
18493   arg1 = (Dali::Handle *)jarg1;
18494   argp2 = (Dali::PropertyNotification *)jarg2;
18495   if (!argp2) {
18496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18497     return ;
18498   }
18499   arg2 = *argp2;
18500   {
18501     try {
18502       (arg1)->RemovePropertyNotification(arg2);
18503     } catch (std::out_of_range& e) {
18504       {
18505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18506       };
18507     } catch (std::exception& e) {
18508       {
18509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (...) {
18512       {
18513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18514       };
18515     }
18516   }
18517 }
18518
18519
18520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18521   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18522
18523   arg1 = (Dali::Handle *)jarg1;
18524   {
18525     try {
18526       (arg1)->RemovePropertyNotifications();
18527     } catch (std::out_of_range& e) {
18528       {
18529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18530       };
18531     } catch (std::exception& e) {
18532       {
18533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (...) {
18536       {
18537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18538       };
18539     }
18540   }
18541 }
18542
18543
18544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18545   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18546
18547   arg1 = (Dali::Handle *)jarg1;
18548   {
18549     try {
18550       (arg1)->RemoveConstraints();
18551     } catch (std::out_of_range& e) {
18552       {
18553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18554       };
18555     } catch (std::exception& e) {
18556       {
18557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18558       };
18559     } catch (...) {
18560       {
18561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18562       };
18563     }
18564   }
18565 }
18566
18567
18568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18569   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18570   unsigned int arg2 ;
18571
18572   arg1 = (Dali::Handle *)jarg1;
18573   arg2 = (unsigned int)jarg2;
18574   {
18575     try {
18576       (arg1)->RemoveConstraints(arg2);
18577     } catch (std::out_of_range& e) {
18578       {
18579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18580       };
18581     } catch (std::exception& e) {
18582       {
18583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18584       };
18585     } catch (...) {
18586       {
18587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18588       };
18589     }
18590   }
18591 }
18592
18593
18594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18595   int jresult ;
18596   Dali::Property::Index result;
18597
18598   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18599   jresult = result;
18600   return jresult;
18601 }
18602
18603
18604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18605   void * jresult ;
18606   Dali::Handle result;
18607
18608   {
18609     try {
18610       result = Dali::WeightObject::New();
18611     } catch (std::out_of_range& e) {
18612       {
18613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18614       };
18615     } catch (std::exception& e) {
18616       {
18617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18618       };
18619     } catch (...) {
18620       {
18621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18622       };
18623     }
18624   }
18625   jresult = new Dali::Handle((const Dali::Handle &)result);
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18631   void * jresult ;
18632   Dali::TypeInfo *result = 0 ;
18633
18634   {
18635     try {
18636       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18637     } catch (std::out_of_range& e) {
18638       {
18639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (std::exception& e) {
18642       {
18643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651   jresult = (void *)result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18657   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18658
18659   arg1 = (Dali::TypeInfo *)jarg1;
18660   {
18661     try {
18662       delete arg1;
18663     } catch (std::out_of_range& e) {
18664       {
18665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18666       };
18667     } catch (std::exception& e) {
18668       {
18669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18670       };
18671     } catch (...) {
18672       {
18673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18674       };
18675     }
18676   }
18677 }
18678
18679
18680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18681   void * jresult ;
18682   Dali::TypeInfo *arg1 = 0 ;
18683   Dali::TypeInfo *result = 0 ;
18684
18685   arg1 = (Dali::TypeInfo *)jarg1;
18686   if (!arg1) {
18687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18688     return 0;
18689   }
18690   {
18691     try {
18692       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18693     } catch (std::out_of_range& e) {
18694       {
18695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (std::exception& e) {
18698       {
18699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18700       };
18701     } catch (...) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18704       };
18705     }
18706   }
18707   jresult = (void *)result;
18708   return jresult;
18709 }
18710
18711
18712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18713   void * jresult ;
18714   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18715   Dali::TypeInfo *arg2 = 0 ;
18716   Dali::TypeInfo *result = 0 ;
18717
18718   arg1 = (Dali::TypeInfo *)jarg1;
18719   arg2 = (Dali::TypeInfo *)jarg2;
18720   if (!arg2) {
18721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18722     return 0;
18723   }
18724   {
18725     try {
18726       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18727     } catch (std::out_of_range& e) {
18728       {
18729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (std::exception& e) {
18732       {
18733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (...) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18738       };
18739     }
18740   }
18741   jresult = (void *)result;
18742   return jresult;
18743 }
18744
18745
18746 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18747   char * jresult ;
18748   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18749   std::string *result = 0 ;
18750
18751   arg1 = (Dali::TypeInfo *)jarg1;
18752   {
18753     try {
18754       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18755     } catch (std::out_of_range& e) {
18756       {
18757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18758       };
18759     } catch (std::exception& e) {
18760       {
18761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (...) {
18764       {
18765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18766       };
18767     }
18768   }
18769   jresult = SWIG_csharp_string_callback(result->c_str());
18770   return jresult;
18771 }
18772
18773
18774 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18775   char * jresult ;
18776   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18777   std::string *result = 0 ;
18778
18779   arg1 = (Dali::TypeInfo *)jarg1;
18780   {
18781     try {
18782       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18783     } catch (std::out_of_range& e) {
18784       {
18785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (std::exception& e) {
18788       {
18789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797   jresult = SWIG_csharp_string_callback(result->c_str());
18798   return jresult;
18799 }
18800
18801
18802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18803   void * jresult ;
18804   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18805   Dali::BaseHandle result;
18806
18807   arg1 = (Dali::TypeInfo *)jarg1;
18808   {
18809     try {
18810       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18811     } catch (std::out_of_range& e) {
18812       {
18813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18814       };
18815     } catch (std::exception& e) {
18816       {
18817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18818       };
18819     } catch (...) {
18820       {
18821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18822       };
18823     }
18824   }
18825   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18826   return jresult;
18827 }
18828
18829
18830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18831   unsigned long jresult ;
18832   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18833   size_t result;
18834
18835   arg1 = (Dali::TypeInfo *)jarg1;
18836   {
18837     try {
18838       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18839     } catch (std::out_of_range& e) {
18840       {
18841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18842       };
18843     } catch (std::exception& e) {
18844       {
18845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18846       };
18847     } catch (...) {
18848       {
18849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18850       };
18851     }
18852   }
18853   jresult = (unsigned long)result;
18854   return jresult;
18855 }
18856
18857
18858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18859   char * jresult ;
18860   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18861   size_t arg2 ;
18862   std::string result;
18863
18864   arg1 = (Dali::TypeInfo *)jarg1;
18865   arg2 = (size_t)jarg2;
18866   {
18867     try {
18868       result = (arg1)->GetActionName(arg2);
18869     } catch (std::out_of_range& e) {
18870       {
18871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18872       };
18873     } catch (std::exception& e) {
18874       {
18875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (...) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18880       };
18881     }
18882   }
18883   jresult = SWIG_csharp_string_callback((&result)->c_str());
18884   return jresult;
18885 }
18886
18887
18888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18889   unsigned long jresult ;
18890   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18891   size_t result;
18892
18893   arg1 = (Dali::TypeInfo *)jarg1;
18894   {
18895     try {
18896       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18897     } catch (std::out_of_range& e) {
18898       {
18899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18900       };
18901     } catch (std::exception& e) {
18902       {
18903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18904       };
18905     } catch (...) {
18906       {
18907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18908       };
18909     }
18910   }
18911   jresult = (unsigned long)result;
18912   return jresult;
18913 }
18914
18915
18916 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18917   char * jresult ;
18918   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18919   size_t arg2 ;
18920   std::string result;
18921
18922   arg1 = (Dali::TypeInfo *)jarg1;
18923   arg2 = (size_t)jarg2;
18924   {
18925     try {
18926       result = (arg1)->GetSignalName(arg2);
18927     } catch (std::out_of_range& e) {
18928       {
18929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18930       };
18931     } catch (std::exception& e) {
18932       {
18933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18934       };
18935     } catch (...) {
18936       {
18937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18938       };
18939     }
18940   }
18941   jresult = SWIG_csharp_string_callback((&result)->c_str());
18942   return jresult;
18943 }
18944
18945
18946 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18947   unsigned long jresult ;
18948   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18949   size_t result;
18950
18951   arg1 = (Dali::TypeInfo *)jarg1;
18952   {
18953     try {
18954       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18955     } catch (std::out_of_range& e) {
18956       {
18957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18958       };
18959     } catch (std::exception& e) {
18960       {
18961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18962       };
18963     } catch (...) {
18964       {
18965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18966       };
18967     }
18968   }
18969   jresult = (unsigned long)result;
18970   return jresult;
18971 }
18972
18973
18974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18975   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18976   Dali::Property::IndexContainer *arg2 = 0 ;
18977
18978   arg1 = (Dali::TypeInfo *)jarg1;
18979   arg2 = (Dali::Property::IndexContainer *)jarg2;
18980   if (!arg2) {
18981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18982     return ;
18983   }
18984   {
18985     try {
18986       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18987     } catch (std::out_of_range& e) {
18988       {
18989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18990       };
18991     } catch (std::exception& e) {
18992       {
18993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (...) {
18996       {
18997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18998       };
18999     }
19000   }
19001 }
19002
19003
19004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19005   char * jresult ;
19006   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19007   Dali::Property::Index arg2 ;
19008   std::string *result = 0 ;
19009
19010   arg1 = (Dali::TypeInfo *)jarg1;
19011   arg2 = (Dali::Property::Index)jarg2;
19012   {
19013     try {
19014       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19015     } catch (std::out_of_range& e) {
19016       {
19017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19018       };
19019     } catch (std::exception& e) {
19020       {
19021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19022       };
19023     } catch (...) {
19024       {
19025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19026       };
19027     }
19028   }
19029   jresult = SWIG_csharp_string_callback(result->c_str());
19030   return jresult;
19031 }
19032
19033
19034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19035   void * jresult ;
19036   Dali::TypeRegistry result;
19037
19038   {
19039     try {
19040       result = Dali::TypeRegistry::Get();
19041     } catch (std::out_of_range& e) {
19042       {
19043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19044       };
19045     } catch (std::exception& e) {
19046       {
19047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19052       };
19053     }
19054   }
19055   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19056   return jresult;
19057 }
19058
19059
19060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19061   void * jresult ;
19062   Dali::TypeRegistry *result = 0 ;
19063
19064   {
19065     try {
19066       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19067     } catch (std::out_of_range& e) {
19068       {
19069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19070       };
19071     } catch (std::exception& e) {
19072       {
19073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19078       };
19079     }
19080   }
19081   jresult = (void *)result;
19082   return jresult;
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19087   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19088
19089   arg1 = (Dali::TypeRegistry *)jarg1;
19090   {
19091     try {
19092       delete arg1;
19093     } catch (std::out_of_range& e) {
19094       {
19095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19096       };
19097     } catch (std::exception& e) {
19098       {
19099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (...) {
19102       {
19103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19104       };
19105     }
19106   }
19107 }
19108
19109
19110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19111   void * jresult ;
19112   Dali::TypeRegistry *arg1 = 0 ;
19113   Dali::TypeRegistry *result = 0 ;
19114
19115   arg1 = (Dali::TypeRegistry *)jarg1;
19116   if (!arg1) {
19117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19118     return 0;
19119   }
19120   {
19121     try {
19122       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19123     } catch (std::out_of_range& e) {
19124       {
19125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19126       };
19127     } catch (std::exception& e) {
19128       {
19129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19130       };
19131     } catch (...) {
19132       {
19133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19134       };
19135     }
19136   }
19137   jresult = (void *)result;
19138   return jresult;
19139 }
19140
19141
19142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19143   void * jresult ;
19144   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19145   Dali::TypeRegistry *arg2 = 0 ;
19146   Dali::TypeRegistry *result = 0 ;
19147
19148   arg1 = (Dali::TypeRegistry *)jarg1;
19149   arg2 = (Dali::TypeRegistry *)jarg2;
19150   if (!arg2) {
19151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19152     return 0;
19153   }
19154   {
19155     try {
19156       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
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 = (void *)result;
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19177   void * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   std::string *arg2 = 0 ;
19180   Dali::TypeInfo result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   if (!jarg2) {
19184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19185     return 0;
19186   }
19187   std::string arg2_str(jarg2);
19188   arg2 = &arg2_str;
19189   {
19190     try {
19191       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (...) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19203       };
19204     }
19205   }
19206   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19207
19208   //argout typemap for const std::string&
19209
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19215   void * jresult ;
19216   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19217   std::type_info *arg2 = 0 ;
19218   Dali::TypeInfo result;
19219
19220   arg1 = (Dali::TypeRegistry *)jarg1;
19221   arg2 = (std::type_info *)jarg2;
19222   if (!arg2) {
19223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19224     return 0;
19225   }
19226   {
19227     try {
19228       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19229     } catch (std::out_of_range& e) {
19230       {
19231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (std::exception& e) {
19234       {
19235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19244   return jresult;
19245 }
19246
19247
19248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19249   unsigned long jresult ;
19250   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19251   size_t result;
19252
19253   arg1 = (Dali::TypeRegistry *)jarg1;
19254   {
19255     try {
19256       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (...) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19268       };
19269     }
19270   }
19271   jresult = (unsigned long)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19277   char * jresult ;
19278   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19279   size_t arg2 ;
19280   std::string result;
19281
19282   arg1 = (Dali::TypeRegistry *)jarg1;
19283   arg2 = (size_t)jarg2;
19284   {
19285     try {
19286       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19287     } catch (std::out_of_range& e) {
19288       {
19289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19290       };
19291     } catch (std::exception& e) {
19292       {
19293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (...) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19298       };
19299     }
19300   }
19301   jresult = SWIG_csharp_string_callback((&result)->c_str());
19302   return jresult;
19303 }
19304
19305
19306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19307   void * jresult ;
19308   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19309   Dali::TypeRegistry *result = 0 ;
19310
19311   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19312   {
19313     try {
19314       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329   jresult = (void *)result;
19330   return jresult;
19331 }
19332
19333
19334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19335   void * jresult ;
19336   std::type_info *arg1 = 0 ;
19337   std::type_info *arg2 = 0 ;
19338   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19339   Dali::TypeRegistration *result = 0 ;
19340
19341   arg1 = (std::type_info *)jarg1;
19342   if (!arg1) {
19343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19344     return 0;
19345   }
19346   arg2 = (std::type_info *)jarg2;
19347   if (!arg2) {
19348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19349     return 0;
19350   }
19351   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19352   {
19353     try {
19354       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19355     } catch (std::out_of_range& e) {
19356       {
19357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19358       };
19359     } catch (std::exception& e) {
19360       {
19361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (...) {
19364       {
19365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19366       };
19367     }
19368   }
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19375   void * jresult ;
19376   std::type_info *arg1 = 0 ;
19377   std::type_info *arg2 = 0 ;
19378   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19379   bool arg4 ;
19380   Dali::TypeRegistration *result = 0 ;
19381
19382   arg1 = (std::type_info *)jarg1;
19383   if (!arg1) {
19384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19385     return 0;
19386   }
19387   arg2 = (std::type_info *)jarg2;
19388   if (!arg2) {
19389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19390     return 0;
19391   }
19392   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19393   arg4 = jarg4 ? true : false;
19394   {
19395     try {
19396       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19397     } catch (std::out_of_range& e) {
19398       {
19399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (std::exception& e) {
19402       {
19403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411   jresult = (void *)result;
19412   return jresult;
19413 }
19414
19415
19416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19417   void * jresult ;
19418   std::string *arg1 = 0 ;
19419   std::type_info *arg2 = 0 ;
19420   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19421   Dali::TypeRegistration *result = 0 ;
19422
19423   if (!jarg1) {
19424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19425     return 0;
19426   }
19427   std::string arg1_str(jarg1);
19428   arg1 = &arg1_str;
19429   arg2 = (std::type_info *)jarg2;
19430   if (!arg2) {
19431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19432     return 0;
19433   }
19434   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19435   {
19436     try {
19437       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19438     } catch (std::out_of_range& e) {
19439       {
19440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19441       };
19442     } catch (std::exception& e) {
19443       {
19444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19445       };
19446     } catch (...) {
19447       {
19448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19449       };
19450     }
19451   }
19452   jresult = (void *)result;
19453
19454   //argout typemap for const std::string&
19455
19456   return jresult;
19457 }
19458
19459
19460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19461   char * jresult ;
19462   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19463   std::string result;
19464
19465   arg1 = (Dali::TypeRegistration *)jarg1;
19466   {
19467     try {
19468       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19469     } catch (std::out_of_range& e) {
19470       {
19471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19472       };
19473     } catch (std::exception& e) {
19474       {
19475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19476       };
19477     } catch (...) {
19478       {
19479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19480       };
19481     }
19482   }
19483   jresult = SWIG_csharp_string_callback((&result)->c_str());
19484   return jresult;
19485 }
19486
19487
19488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19489   std::string *arg1 = 0 ;
19490   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19491
19492   if (!jarg1) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19494     return ;
19495   }
19496   std::string arg1_str(jarg1);
19497   arg1 = &arg1_str;
19498   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19499   {
19500     try {
19501       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19502     } catch (std::out_of_range& e) {
19503       {
19504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19505       };
19506     } catch (std::exception& e) {
19507       {
19508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19513       };
19514     }
19515   }
19516
19517   //argout typemap for const std::string&
19518
19519 }
19520
19521
19522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19523   std::string *arg1 = 0 ;
19524   std::string *arg2 = 0 ;
19525   int arg3 ;
19526   Dali::Property::Type arg4 ;
19527   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19528   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19529
19530   if (!jarg1) {
19531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19532     return ;
19533   }
19534   std::string arg1_str(jarg1);
19535   arg1 = &arg1_str;
19536   if (!jarg2) {
19537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19538     return ;
19539   }
19540   std::string arg2_str(jarg2);
19541   arg2 = &arg2_str;
19542   arg3 = (int)jarg3;
19543   arg4 = (Dali::Property::Type)jarg4;
19544   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19545   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19546   {
19547     try {
19548       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19549     } catch (std::out_of_range& e) {
19550       {
19551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19552       };
19553     } catch (std::exception& e) {
19554       {
19555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19556       };
19557     } catch (...) {
19558       {
19559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19560       };
19561     }
19562   }
19563
19564   //argout typemap for const std::string&
19565
19566
19567   //argout typemap for const std::string&
19568
19569 }
19570
19571
19572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19573   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19574
19575   arg1 = (Dali::TypeRegistration *)jarg1;
19576   {
19577     try {
19578       delete arg1;
19579     } catch (std::out_of_range& e) {
19580       {
19581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19582       };
19583     } catch (std::exception& e) {
19584       {
19585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19586       };
19587     } catch (...) {
19588       {
19589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19590       };
19591     }
19592   }
19593 }
19594
19595
19596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19597   void * jresult ;
19598   Dali::TypeRegistration *arg1 = 0 ;
19599   std::string *arg2 = 0 ;
19600   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19601   Dali::SignalConnectorType *result = 0 ;
19602
19603   arg1 = (Dali::TypeRegistration *)jarg1;
19604   if (!arg1) {
19605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19606     return 0;
19607   }
19608   if (!jarg2) {
19609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19610     return 0;
19611   }
19612   std::string arg2_str(jarg2);
19613   arg2 = &arg2_str;
19614   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19615   {
19616     try {
19617       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19618     } catch (std::out_of_range& e) {
19619       {
19620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19621       };
19622     } catch (std::exception& e) {
19623       {
19624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (...) {
19627       {
19628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19629       };
19630     }
19631   }
19632   jresult = (void *)result;
19633
19634   //argout typemap for const std::string&
19635
19636   return jresult;
19637 }
19638
19639
19640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19641   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19642
19643   arg1 = (Dali::SignalConnectorType *)jarg1;
19644   {
19645     try {
19646       delete arg1;
19647     } catch (std::out_of_range& e) {
19648       {
19649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19650       };
19651     } catch (std::exception& e) {
19652       {
19653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19658       };
19659     }
19660   }
19661 }
19662
19663
19664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19665   void * jresult ;
19666   Dali::TypeRegistration *arg1 = 0 ;
19667   std::string *arg2 = 0 ;
19668   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19669   Dali::TypeAction *result = 0 ;
19670
19671   arg1 = (Dali::TypeRegistration *)jarg1;
19672   if (!arg1) {
19673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19674     return 0;
19675   }
19676   if (!jarg2) {
19677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19678     return 0;
19679   }
19680   std::string arg2_str(jarg2);
19681   arg2 = &arg2_str;
19682   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19683   {
19684     try {
19685       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19686     } catch (std::out_of_range& e) {
19687       {
19688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19689       };
19690     } catch (std::exception& e) {
19691       {
19692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19693       };
19694     } catch (...) {
19695       {
19696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19697       };
19698     }
19699   }
19700   jresult = (void *)result;
19701
19702   //argout typemap for const std::string&
19703
19704   return jresult;
19705 }
19706
19707
19708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19709   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19710
19711   arg1 = (Dali::TypeAction *)jarg1;
19712   {
19713     try {
19714       delete arg1;
19715     } catch (std::out_of_range& e) {
19716       {
19717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19718       };
19719     } catch (std::exception& e) {
19720       {
19721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19726       };
19727     }
19728   }
19729 }
19730
19731
19732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19733   void * jresult ;
19734   Dali::TypeRegistration *arg1 = 0 ;
19735   std::string *arg2 = 0 ;
19736   Dali::Property::Index arg3 ;
19737   Dali::Property::Type arg4 ;
19738   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19739   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19740   Dali::PropertyRegistration *result = 0 ;
19741
19742   arg1 = (Dali::TypeRegistration *)jarg1;
19743   if (!arg1) {
19744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19745     return 0;
19746   }
19747   if (!jarg2) {
19748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19749     return 0;
19750   }
19751   std::string arg2_str(jarg2);
19752   arg2 = &arg2_str;
19753   arg3 = (Dali::Property::Index)jarg3;
19754   arg4 = (Dali::Property::Type)jarg4;
19755   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19756   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19757   {
19758     try {
19759       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (...) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19771       };
19772     }
19773   }
19774   jresult = (void *)result;
19775
19776   //argout typemap for const std::string&
19777
19778   return jresult;
19779 }
19780
19781
19782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19783   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19784
19785   arg1 = (Dali::PropertyRegistration *)jarg1;
19786   {
19787     try {
19788       delete arg1;
19789     } catch (std::out_of_range& e) {
19790       {
19791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19792       };
19793     } catch (std::exception& e) {
19794       {
19795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19796       };
19797     } catch (...) {
19798       {
19799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19800       };
19801     }
19802   }
19803 }
19804
19805
19806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19807   void * jresult ;
19808   Dali::TypeRegistration *arg1 = 0 ;
19809   std::string *arg2 = 0 ;
19810   Dali::Property::Index arg3 ;
19811   Dali::Property::Type arg4 ;
19812   Dali::AnimatablePropertyRegistration *result = 0 ;
19813
19814   arg1 = (Dali::TypeRegistration *)jarg1;
19815   if (!arg1) {
19816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19817     return 0;
19818   }
19819   if (!jarg2) {
19820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19821     return 0;
19822   }
19823   std::string arg2_str(jarg2);
19824   arg2 = &arg2_str;
19825   arg3 = (Dali::Property::Index)jarg3;
19826   arg4 = (Dali::Property::Type)jarg4;
19827   {
19828     try {
19829       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19830     } catch (std::out_of_range& e) {
19831       {
19832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19833       };
19834     } catch (std::exception& e) {
19835       {
19836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19837       };
19838     } catch (...) {
19839       {
19840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19841       };
19842     }
19843   }
19844   jresult = (void *)result;
19845
19846   //argout typemap for const std::string&
19847
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19853   void * jresult ;
19854   Dali::TypeRegistration *arg1 = 0 ;
19855   std::string *arg2 = 0 ;
19856   Dali::Property::Index arg3 ;
19857   Dali::Property::Value *arg4 = 0 ;
19858   Dali::AnimatablePropertyRegistration *result = 0 ;
19859
19860   arg1 = (Dali::TypeRegistration *)jarg1;
19861   if (!arg1) {
19862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19863     return 0;
19864   }
19865   if (!jarg2) {
19866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19867     return 0;
19868   }
19869   std::string arg2_str(jarg2);
19870   arg2 = &arg2_str;
19871   arg3 = (Dali::Property::Index)jarg3;
19872   arg4 = (Dali::Property::Value *)jarg4;
19873   if (!arg4) {
19874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19875     return 0;
19876   }
19877   {
19878     try {
19879       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19880     } catch (std::out_of_range& e) {
19881       {
19882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19883       };
19884     } catch (std::exception& e) {
19885       {
19886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19887       };
19888     } catch (...) {
19889       {
19890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19891       };
19892     }
19893   }
19894   jresult = (void *)result;
19895
19896   //argout typemap for const std::string&
19897
19898   return jresult;
19899 }
19900
19901
19902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19903   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19904
19905   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19906   {
19907     try {
19908       delete arg1;
19909     } catch (std::out_of_range& e) {
19910       {
19911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19912       };
19913     } catch (std::exception& e) {
19914       {
19915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19916       };
19917     } catch (...) {
19918       {
19919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19920       };
19921     }
19922   }
19923 }
19924
19925
19926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19927   void * jresult ;
19928   Dali::TypeRegistration *arg1 = 0 ;
19929   std::string *arg2 = 0 ;
19930   Dali::Property::Index arg3 ;
19931   Dali::Property::Index arg4 ;
19932   unsigned int arg5 ;
19933   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19934
19935   arg1 = (Dali::TypeRegistration *)jarg1;
19936   if (!arg1) {
19937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19938     return 0;
19939   }
19940   if (!jarg2) {
19941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19942     return 0;
19943   }
19944   std::string arg2_str(jarg2);
19945   arg2 = &arg2_str;
19946   arg3 = (Dali::Property::Index)jarg3;
19947   arg4 = (Dali::Property::Index)jarg4;
19948   arg5 = (unsigned int)jarg5;
19949   {
19950     try {
19951       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (...) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19963       };
19964     }
19965   }
19966   jresult = (void *)result;
19967
19968   //argout typemap for const std::string&
19969
19970   return jresult;
19971 }
19972
19973
19974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19975   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19976
19977   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19978   {
19979     try {
19980       delete arg1;
19981     } catch (std::out_of_range& e) {
19982       {
19983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19984       };
19985     } catch (std::exception& e) {
19986       {
19987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19988       };
19989     } catch (...) {
19990       {
19991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19992       };
19993     }
19994   }
19995 }
19996
19997
19998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19999   void * jresult ;
20000   Dali::TypeRegistration *arg1 = 0 ;
20001   std::string *arg2 = 0 ;
20002   Dali::Property::Index arg3 ;
20003   Dali::Property::Type arg4 ;
20004   Dali::ChildPropertyRegistration *result = 0 ;
20005
20006   arg1 = (Dali::TypeRegistration *)jarg1;
20007   if (!arg1) {
20008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20009     return 0;
20010   }
20011   if (!jarg2) {
20012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20013     return 0;
20014   }
20015   std::string arg2_str(jarg2);
20016   arg2 = &arg2_str;
20017   arg3 = (Dali::Property::Index)jarg3;
20018   arg4 = (Dali::Property::Type)jarg4;
20019   {
20020     try {
20021       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20022     } catch (std::out_of_range& e) {
20023       {
20024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20025       };
20026     } catch (std::exception& e) {
20027       {
20028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (...) {
20031       {
20032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20033       };
20034     }
20035   }
20036   jresult = (void *)result;
20037
20038   //argout typemap for const std::string&
20039
20040   return jresult;
20041 }
20042
20043
20044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20045   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20046
20047   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20048   {
20049     try {
20050       delete arg1;
20051     } catch (std::out_of_range& e) {
20052       {
20053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20054       };
20055     } catch (std::exception& e) {
20056       {
20057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20058       };
20059     } catch (...) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20062       };
20063     }
20064   }
20065 }
20066
20067
20068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20069   unsigned int jresult ;
20070   std::string *arg1 = 0 ;
20071   std::type_info *arg2 = 0 ;
20072   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20073   bool result;
20074
20075   if (!jarg1) {
20076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20077     return 0;
20078   }
20079   std::string arg1_str(jarg1);
20080   arg1 = &arg1_str;
20081   arg2 = (std::type_info *)jarg2;
20082   if (!arg2) {
20083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20084     return 0;
20085   }
20086   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20087   {
20088     try {
20089       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20090     } catch (std::out_of_range& e) {
20091       {
20092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20093       };
20094     } catch (std::exception& e) {
20095       {
20096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (...) {
20099       {
20100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20101       };
20102     }
20103   }
20104   jresult = result;
20105
20106   //argout typemap for const std::string&
20107
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20113   unsigned int jresult ;
20114   std::string *arg1 = 0 ;
20115   std::string *arg2 = 0 ;
20116   Dali::Property::Index arg3 ;
20117   Dali::Property::Type arg4 ;
20118   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20119   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20120   bool result;
20121
20122   if (!jarg1) {
20123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20124     return 0;
20125   }
20126   std::string arg1_str(jarg1);
20127   arg1 = &arg1_str;
20128   if (!jarg2) {
20129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20130     return 0;
20131   }
20132   std::string arg2_str(jarg2);
20133   arg2 = &arg2_str;
20134   arg3 = (Dali::Property::Index)jarg3;
20135   arg4 = (Dali::Property::Type)jarg4;
20136   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20137   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20138   {
20139     try {
20140       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20141     } catch (std::out_of_range& e) {
20142       {
20143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20144       };
20145     } catch (std::exception& e) {
20146       {
20147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20148       };
20149     } catch (...) {
20150       {
20151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20152       };
20153     }
20154   }
20155   jresult = result;
20156
20157   //argout typemap for const std::string&
20158
20159
20160   //argout typemap for const std::string&
20161
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20167   float jresult ;
20168   float result;
20169
20170   result = (float)(float)Dali::ParentOrigin::TOP;
20171   jresult = result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20177   float jresult ;
20178   float result;
20179
20180   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20187   float jresult ;
20188   float result;
20189
20190   result = (float)(float)Dali::ParentOrigin::LEFT;
20191   jresult = result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20197   float jresult ;
20198   float result;
20199
20200   result = (float)(float)Dali::ParentOrigin::RIGHT;
20201   jresult = result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20207   float jresult ;
20208   float result;
20209
20210   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20211   jresult = result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20217   void * jresult ;
20218   Dali::Vector3 *result = 0 ;
20219
20220   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20227   void * jresult ;
20228   Dali::Vector3 *result = 0 ;
20229
20230   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20237   void * jresult ;
20238   Dali::Vector3 *result = 0 ;
20239
20240   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20247   void * jresult ;
20248   Dali::Vector3 *result = 0 ;
20249
20250   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20287   void * jresult ;
20288   Dali::Vector3 *result = 0 ;
20289
20290   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20291   jresult = (void *)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20297   void * jresult ;
20298   Dali::Vector3 *result = 0 ;
20299
20300   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20301   jresult = (void *)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20307   float jresult ;
20308   float result;
20309
20310   result = (float)(float)Dali::AnchorPoint::TOP;
20311   jresult = result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20317   float jresult ;
20318   float result;
20319
20320   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20327   float jresult ;
20328   float result;
20329
20330   result = (float)(float)Dali::AnchorPoint::LEFT;
20331   jresult = result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20337   float jresult ;
20338   float result;
20339
20340   result = (float)(float)Dali::AnchorPoint::RIGHT;
20341   jresult = result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20347   float jresult ;
20348   float result;
20349
20350   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20351   jresult = result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20357   void * jresult ;
20358   Dali::Vector3 *result = 0 ;
20359
20360   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20367   void * jresult ;
20368   Dali::Vector3 *result = 0 ;
20369
20370   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20377   void * jresult ;
20378   Dali::Vector3 *result = 0 ;
20379
20380   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20387   void * jresult ;
20388   Dali::Vector3 *result = 0 ;
20389
20390   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20397   void * jresult ;
20398   Dali::Vector3 *result = 0 ;
20399
20400   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20407   void * jresult ;
20408   Dali::Vector3 *result = 0 ;
20409
20410   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20417   void * jresult ;
20418   Dali::Vector3 *result = 0 ;
20419
20420   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20427   void * jresult ;
20428   Dali::Vector3 *result = 0 ;
20429
20430   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20437   void * jresult ;
20438   Dali::Vector3 *result = 0 ;
20439
20440   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20447   void * jresult ;
20448   Dali::Vector4 *result = 0 ;
20449
20450   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20457   void * jresult ;
20458   Dali::Vector4 *result = 0 ;
20459
20460   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20461   jresult = (void *)result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20467   void * jresult ;
20468   Dali::Vector4 *result = 0 ;
20469
20470   result = (Dali::Vector4 *)&Dali::Color::RED;
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20477   void * jresult ;
20478   Dali::Vector4 *result = 0 ;
20479
20480   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20481   jresult = (void *)result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20487   void * jresult ;
20488   Dali::Vector4 *result = 0 ;
20489
20490   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20491   jresult = (void *)result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20497   void * jresult ;
20498   Dali::Vector4 *result = 0 ;
20499
20500   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20501   jresult = (void *)result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20507   void * jresult ;
20508   Dali::Vector4 *result = 0 ;
20509
20510   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20511   jresult = (void *)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20517   void * jresult ;
20518   Dali::Vector4 *result = 0 ;
20519
20520   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20521   jresult = (void *)result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20527   void * jresult ;
20528   Dali::Vector4 *result = 0 ;
20529
20530   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20531   jresult = (void *)result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20547   float jresult ;
20548   float result;
20549
20550   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20557   float jresult ;
20558   float result;
20559
20560   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20561   jresult = result;
20562   return jresult;
20563 }
20564
20565
20566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20567   float jresult ;
20568   float result;
20569
20570   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20577   float jresult ;
20578   float result;
20579
20580   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20581   jresult = result;
20582   return jresult;
20583 }
20584
20585
20586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20587   float jresult ;
20588   float result;
20589
20590   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20591   jresult = result;
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20597   float jresult ;
20598   float result;
20599
20600   result = (float)(float)Dali::Math::PI;
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20607   float jresult ;
20608   float result;
20609
20610   result = (float)(float)Dali::Math::PI_2;
20611   jresult = result;
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20617   float jresult ;
20618   float result;
20619
20620   result = (float)(float)Dali::Math::PI_4;
20621   jresult = result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20627   float jresult ;
20628   float result;
20629
20630   result = (float)(float)Dali::Math::PI_OVER_180;
20631   jresult = result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20637   float jresult ;
20638   float result;
20639
20640   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20641   jresult = result;
20642   return jresult;
20643 }
20644
20645
20646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20647   int jresult ;
20648   Dali::ResizePolicy::Type result;
20649
20650   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20651   jresult = (int)result;
20652   return jresult;
20653 }
20654
20655
20656 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20657   unsigned long jresult ;
20658   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20659   Dali::VectorBase::SizeType result;
20660
20661   arg1 = (Dali::VectorBase *)jarg1;
20662   {
20663     try {
20664       result = ((Dali::VectorBase const *)arg1)->Count();
20665     } catch (std::out_of_range& e) {
20666       {
20667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (std::exception& e) {
20670       {
20671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679   jresult = (unsigned long)result;
20680   return jresult;
20681 }
20682
20683
20684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20685   unsigned long jresult ;
20686   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20687   Dali::VectorBase::SizeType result;
20688
20689   arg1 = (Dali::VectorBase *)jarg1;
20690   {
20691     try {
20692       result = ((Dali::VectorBase const *)arg1)->Size();
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (...) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20704       };
20705     }
20706   }
20707   jresult = (unsigned long)result;
20708   return jresult;
20709 }
20710
20711
20712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20713   unsigned int jresult ;
20714   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20715   bool result;
20716
20717   arg1 = (Dali::VectorBase *)jarg1;
20718   {
20719     try {
20720       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20721     } catch (std::out_of_range& e) {
20722       {
20723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20724       };
20725     } catch (std::exception& e) {
20726       {
20727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20728       };
20729     } catch (...) {
20730       {
20731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20732       };
20733     }
20734   }
20735   jresult = result;
20736   return jresult;
20737 }
20738
20739
20740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20741   unsigned long jresult ;
20742   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20743   Dali::VectorBase::SizeType result;
20744
20745   arg1 = (Dali::VectorBase *)jarg1;
20746   {
20747     try {
20748       result = ((Dali::VectorBase const *)arg1)->Capacity();
20749     } catch (std::out_of_range& e) {
20750       {
20751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20752       };
20753     } catch (std::exception& e) {
20754       {
20755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20756       };
20757     } catch (...) {
20758       {
20759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20760       };
20761     }
20762   }
20763   jresult = (unsigned long)result;
20764   return jresult;
20765 }
20766
20767
20768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20769   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20770
20771   arg1 = (Dali::VectorBase *)jarg1;
20772   {
20773     try {
20774       (arg1)->Release();
20775     } catch (std::out_of_range& e) {
20776       {
20777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20778       };
20779     } catch (std::exception& e) {
20780       {
20781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20786       };
20787     }
20788   }
20789 }
20790
20791
20792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20793   void * jresult ;
20794   Dali::Image *result = 0 ;
20795
20796   {
20797     try {
20798       result = (Dali::Image *)new Dali::Image();
20799     } catch (std::out_of_range& e) {
20800       {
20801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (std::exception& e) {
20804       {
20805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20806       };
20807     } catch (...) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20810       };
20811     }
20812   }
20813   jresult = (void *)result;
20814   return jresult;
20815 }
20816
20817
20818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20819   Dali::Image *arg1 = (Dali::Image *) 0 ;
20820
20821   arg1 = (Dali::Image *)jarg1;
20822   {
20823     try {
20824       delete arg1;
20825     } catch (std::out_of_range& e) {
20826       {
20827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20828       };
20829     } catch (std::exception& e) {
20830       {
20831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20832       };
20833     } catch (...) {
20834       {
20835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20836       };
20837     }
20838   }
20839 }
20840
20841
20842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20843   void * jresult ;
20844   Dali::Image *arg1 = 0 ;
20845   Dali::Image *result = 0 ;
20846
20847   arg1 = (Dali::Image *)jarg1;
20848   if (!arg1) {
20849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20850     return 0;
20851   }
20852   {
20853     try {
20854       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20855     } catch (std::out_of_range& e) {
20856       {
20857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (std::exception& e) {
20860       {
20861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20862       };
20863     } catch (...) {
20864       {
20865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20866       };
20867     }
20868   }
20869   jresult = (void *)result;
20870   return jresult;
20871 }
20872
20873
20874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20875   void * jresult ;
20876   Dali::Image *arg1 = (Dali::Image *) 0 ;
20877   Dali::Image *arg2 = 0 ;
20878   Dali::Image *result = 0 ;
20879
20880   arg1 = (Dali::Image *)jarg1;
20881   arg2 = (Dali::Image *)jarg2;
20882   if (!arg2) {
20883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20884     return 0;
20885   }
20886   {
20887     try {
20888       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20889     } catch (std::out_of_range& e) {
20890       {
20891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20892       };
20893     } catch (std::exception& e) {
20894       {
20895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20896       };
20897     } catch (...) {
20898       {
20899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20900       };
20901     }
20902   }
20903   jresult = (void *)result;
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20909   void * jresult ;
20910   Dali::BaseHandle arg1 ;
20911   Dali::BaseHandle *argp1 ;
20912   Dali::Image result;
20913
20914   argp1 = (Dali::BaseHandle *)jarg1;
20915   if (!argp1) {
20916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20917     return 0;
20918   }
20919   arg1 = *argp1;
20920   {
20921     try {
20922       result = Dali::Image::DownCast(arg1);
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937   jresult = new Dali::Image((const Dali::Image &)result);
20938   return jresult;
20939 }
20940
20941
20942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20943   unsigned int jresult ;
20944   Dali::Image *arg1 = (Dali::Image *) 0 ;
20945   unsigned int result;
20946
20947   arg1 = (Dali::Image *)jarg1;
20948   {
20949     try {
20950       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20951     } catch (std::out_of_range& e) {
20952       {
20953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20954       };
20955     } catch (std::exception& e) {
20956       {
20957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (...) {
20960       {
20961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20962       };
20963     }
20964   }
20965   jresult = result;
20966   return jresult;
20967 }
20968
20969
20970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20971   unsigned int jresult ;
20972   Dali::Image *arg1 = (Dali::Image *) 0 ;
20973   unsigned int result;
20974
20975   arg1 = (Dali::Image *)jarg1;
20976   {
20977     try {
20978       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20979     } catch (std::out_of_range& e) {
20980       {
20981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20982       };
20983     } catch (std::exception& e) {
20984       {
20985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (...) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20990       };
20991     }
20992   }
20993   jresult = result;
20994   return jresult;
20995 }
20996
20997
20998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20999   void * jresult ;
21000   Dali::Image *arg1 = (Dali::Image *) 0 ;
21001   Dali::Image::ImageSignalType *result = 0 ;
21002
21003   arg1 = (Dali::Image *)jarg1;
21004   {
21005     try {
21006       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21007     } catch (std::out_of_range& e) {
21008       {
21009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (std::exception& e) {
21012       {
21013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21014       };
21015     } catch (...) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21018       };
21019     }
21020   }
21021   jresult = (void *)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21027   int jresult ;
21028   Dali::Pixel::Format result;
21029
21030   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21031   jresult = (int)result;
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21037   int jresult ;
21038   Dali::Pixel::Format result;
21039
21040   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21041   jresult = (int)result;
21042   return jresult;
21043 }
21044
21045
21046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21047   unsigned int jresult ;
21048   Dali::Pixel::Format arg1 ;
21049   bool result;
21050
21051   arg1 = (Dali::Pixel::Format)jarg1;
21052   {
21053     try {
21054       result = (bool)Dali::Pixel::HasAlpha(arg1);
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (...) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21066       };
21067     }
21068   }
21069   jresult = result;
21070   return jresult;
21071 }
21072
21073
21074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21075   unsigned int jresult ;
21076   Dali::Pixel::Format arg1 ;
21077   unsigned int result;
21078
21079   arg1 = (Dali::Pixel::Format)jarg1;
21080   {
21081     try {
21082       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21094       };
21095     }
21096   }
21097   jresult = result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21103   Dali::Pixel::Format arg1 ;
21104   int *arg2 = 0 ;
21105   int *arg3 = 0 ;
21106
21107   arg1 = (Dali::Pixel::Format)jarg1;
21108   arg2 = (int *)jarg2;
21109   if (!arg2) {
21110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21111     return ;
21112   }
21113   arg3 = (int *)jarg3;
21114   if (!arg3) {
21115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21116     return ;
21117   }
21118   {
21119     try {
21120       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21121     } catch (std::out_of_range& e) {
21122       {
21123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21124       };
21125     } catch (std::exception& e) {
21126       {
21127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21128       };
21129     } catch (...) {
21130       {
21131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21132       };
21133     }
21134   }
21135 }
21136
21137
21138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21139   void * jresult ;
21140   unsigned char *arg1 = (unsigned char *) 0 ;
21141   unsigned int arg2 ;
21142   unsigned int arg3 ;
21143   unsigned int arg4 ;
21144   Dali::Pixel::Format arg5 ;
21145   Dali::PixelData::ReleaseFunction arg6 ;
21146   Dali::PixelData result;
21147
21148   arg1 = jarg1;
21149   arg2 = (unsigned int)jarg2;
21150   arg3 = (unsigned int)jarg3;
21151   arg4 = (unsigned int)jarg4;
21152   arg5 = (Dali::Pixel::Format)jarg5;
21153   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21154   {
21155     try {
21156       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21157     } catch (std::out_of_range& e) {
21158       {
21159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21160       };
21161     } catch (std::exception& e) {
21162       {
21163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21164       };
21165     } catch (...) {
21166       {
21167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21168       };
21169     }
21170   }
21171   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21172
21173
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21179   void * jresult ;
21180   Dali::PixelData *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::PixelData *)new Dali::PixelData();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (...) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21196       };
21197     }
21198   }
21199   jresult = (void *)result;
21200   return jresult;
21201 }
21202
21203
21204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21205   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21206
21207   arg1 = (Dali::PixelData *)jarg1;
21208   {
21209     try {
21210       delete arg1;
21211     } catch (std::out_of_range& e) {
21212       {
21213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21214       };
21215     } catch (std::exception& e) {
21216       {
21217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21218       };
21219     } catch (...) {
21220       {
21221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21222       };
21223     }
21224   }
21225 }
21226
21227
21228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21229   void * jresult ;
21230   Dali::PixelData *arg1 = 0 ;
21231   Dali::PixelData *result = 0 ;
21232
21233   arg1 = (Dali::PixelData *)jarg1;
21234   if (!arg1) {
21235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21236     return 0;
21237   }
21238   {
21239     try {
21240       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21241     } catch (std::out_of_range& e) {
21242       {
21243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21244       };
21245     } catch (std::exception& e) {
21246       {
21247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21248       };
21249     } catch (...) {
21250       {
21251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21252       };
21253     }
21254   }
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21261   void * jresult ;
21262   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21263   Dali::PixelData *arg2 = 0 ;
21264   Dali::PixelData *result = 0 ;
21265
21266   arg1 = (Dali::PixelData *)jarg1;
21267   arg2 = (Dali::PixelData *)jarg2;
21268   if (!arg2) {
21269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21270     return 0;
21271   }
21272   {
21273     try {
21274       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21275     } catch (std::out_of_range& e) {
21276       {
21277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21278       };
21279     } catch (std::exception& e) {
21280       {
21281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (...) {
21284       {
21285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21286       };
21287     }
21288   }
21289   jresult = (void *)result;
21290   return jresult;
21291 }
21292
21293
21294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21295   unsigned int jresult ;
21296   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21297   unsigned int result;
21298
21299   arg1 = (Dali::PixelData *)jarg1;
21300   {
21301     try {
21302       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21303     } catch (std::out_of_range& e) {
21304       {
21305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21306       };
21307     } catch (std::exception& e) {
21308       {
21309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21310       };
21311     } catch (...) {
21312       {
21313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21314       };
21315     }
21316   }
21317   jresult = result;
21318   return jresult;
21319 }
21320
21321
21322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21323   unsigned int jresult ;
21324   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21325   unsigned int result;
21326
21327   arg1 = (Dali::PixelData *)jarg1;
21328   {
21329     try {
21330       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21331     } catch (std::out_of_range& e) {
21332       {
21333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21334       };
21335     } catch (std::exception& e) {
21336       {
21337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21338       };
21339     } catch (...) {
21340       {
21341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21342       };
21343     }
21344   }
21345   jresult = result;
21346   return jresult;
21347 }
21348
21349
21350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21351   int jresult ;
21352   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21353   Dali::Pixel::Format result;
21354
21355   arg1 = (Dali::PixelData *)jarg1;
21356   {
21357     try {
21358       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21359     } catch (std::out_of_range& e) {
21360       {
21361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21362       };
21363     } catch (std::exception& e) {
21364       {
21365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21366       };
21367     } catch (...) {
21368       {
21369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21370       };
21371     }
21372   }
21373   jresult = (int)result;
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21379   unsigned int jresult ;
21380   unsigned int result;
21381
21382   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21389   unsigned int jresult ;
21390   unsigned int result;
21391
21392   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21393   jresult = result;
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21399   unsigned int jresult ;
21400   unsigned int result;
21401
21402   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21403   jresult = result;
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21409   unsigned int jresult ;
21410   unsigned int result;
21411
21412   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21413   jresult = result;
21414   return jresult;
21415 }
21416
21417
21418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21419   unsigned int jresult ;
21420   unsigned int result;
21421
21422   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21423   jresult = result;
21424   return jresult;
21425 }
21426
21427
21428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21429   unsigned int jresult ;
21430   unsigned int result;
21431
21432   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21433   jresult = result;
21434   return jresult;
21435 }
21436
21437
21438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21439   void * jresult ;
21440   Dali::TextureType::Type arg1 ;
21441   Dali::Pixel::Format arg2 ;
21442   unsigned int arg3 ;
21443   unsigned int arg4 ;
21444   Dali::Texture result;
21445
21446   arg1 = (Dali::TextureType::Type)jarg1;
21447   arg2 = (Dali::Pixel::Format)jarg2;
21448   arg3 = (unsigned int)jarg3;
21449   arg4 = (unsigned int)jarg4;
21450   {
21451     try {
21452       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21464       };
21465     }
21466   }
21467   jresult = new Dali::Texture((const Dali::Texture &)result);
21468   return jresult;
21469 }
21470
21471
21472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21473   void * jresult ;
21474   NativeImageInterface *arg1 = 0 ;
21475   Dali::Texture result;
21476
21477   arg1 = (NativeImageInterface *)jarg1;
21478   if (!arg1) {
21479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21480     return 0;
21481   }
21482   {
21483     try {
21484       result = Dali::Texture::New(*arg1);
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (...) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21496       };
21497     }
21498   }
21499   jresult = new Dali::Texture((const Dali::Texture &)result);
21500   return jresult;
21501 }
21502
21503
21504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21505   void * jresult ;
21506   Dali::Texture *result = 0 ;
21507
21508   {
21509     try {
21510       result = (Dali::Texture *)new Dali::Texture();
21511     } catch (std::out_of_range& e) {
21512       {
21513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (std::exception& e) {
21516       {
21517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21518       };
21519     } catch (...) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21522       };
21523     }
21524   }
21525   jresult = (void *)result;
21526   return jresult;
21527 }
21528
21529
21530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21531   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21532
21533   arg1 = (Dali::Texture *)jarg1;
21534   {
21535     try {
21536       delete arg1;
21537     } catch (std::out_of_range& e) {
21538       {
21539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21540       };
21541     } catch (std::exception& e) {
21542       {
21543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21544       };
21545     } catch (...) {
21546       {
21547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21548       };
21549     }
21550   }
21551 }
21552
21553
21554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21555   void * jresult ;
21556   Dali::Texture *arg1 = 0 ;
21557   Dali::Texture *result = 0 ;
21558
21559   arg1 = (Dali::Texture *)jarg1;
21560   if (!arg1) {
21561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21562     return 0;
21563   }
21564   {
21565     try {
21566       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21567     } catch (std::out_of_range& e) {
21568       {
21569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21570       };
21571     } catch (std::exception& e) {
21572       {
21573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21574       };
21575     } catch (...) {
21576       {
21577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21578       };
21579     }
21580   }
21581   jresult = (void *)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21587   void * jresult ;
21588   Dali::BaseHandle arg1 ;
21589   Dali::BaseHandle *argp1 ;
21590   Dali::Texture result;
21591
21592   argp1 = (Dali::BaseHandle *)jarg1;
21593   if (!argp1) {
21594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21595     return 0;
21596   }
21597   arg1 = *argp1;
21598   {
21599     try {
21600       result = Dali::Texture::DownCast(arg1);
21601     } catch (std::out_of_range& e) {
21602       {
21603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (std::exception& e) {
21606       {
21607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21608       };
21609     } catch (...) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21612       };
21613     }
21614   }
21615   jresult = new Dali::Texture((const Dali::Texture &)result);
21616   return jresult;
21617 }
21618
21619
21620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21621   void * jresult ;
21622   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21623   Dali::Texture *arg2 = 0 ;
21624   Dali::Texture *result = 0 ;
21625
21626   arg1 = (Dali::Texture *)jarg1;
21627   arg2 = (Dali::Texture *)jarg2;
21628   if (!arg2) {
21629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21630     return 0;
21631   }
21632   {
21633     try {
21634       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21635     } catch (std::out_of_range& e) {
21636       {
21637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21638       };
21639     } catch (std::exception& e) {
21640       {
21641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21642       };
21643     } catch (...) {
21644       {
21645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21646       };
21647     }
21648   }
21649   jresult = (void *)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21655   unsigned int jresult ;
21656   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21657   Dali::PixelData arg2 ;
21658   Dali::PixelData *argp2 ;
21659   bool result;
21660
21661   arg1 = (Dali::Texture *)jarg1;
21662   argp2 = (Dali::PixelData *)jarg2;
21663   if (!argp2) {
21664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21665     return 0;
21666   }
21667   arg2 = *argp2;
21668   {
21669     try {
21670       result = (bool)(arg1)->Upload(arg2);
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_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) {
21691   unsigned int jresult ;
21692   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21693   Dali::PixelData arg2 ;
21694   unsigned int arg3 ;
21695   unsigned int arg4 ;
21696   unsigned int arg5 ;
21697   unsigned int arg6 ;
21698   unsigned int arg7 ;
21699   unsigned int arg8 ;
21700   Dali::PixelData *argp2 ;
21701   bool result;
21702
21703   arg1 = (Dali::Texture *)jarg1;
21704   argp2 = (Dali::PixelData *)jarg2;
21705   if (!argp2) {
21706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21707     return 0;
21708   }
21709   arg2 = *argp2;
21710   arg3 = (unsigned int)jarg3;
21711   arg4 = (unsigned int)jarg4;
21712   arg5 = (unsigned int)jarg5;
21713   arg6 = (unsigned int)jarg6;
21714   arg7 = (unsigned int)jarg7;
21715   arg8 = (unsigned int)jarg8;
21716   {
21717     try {
21718       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21726       };
21727     } catch (...) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21730       };
21731     }
21732   }
21733   jresult = result;
21734   return jresult;
21735 }
21736
21737
21738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21739   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21740
21741   arg1 = (Dali::Texture *)jarg1;
21742   {
21743     try {
21744       (arg1)->GenerateMipmaps();
21745     } catch (std::out_of_range& e) {
21746       {
21747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21748       };
21749     } catch (std::exception& e) {
21750       {
21751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21756       };
21757     }
21758   }
21759 }
21760
21761
21762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21763   unsigned int jresult ;
21764   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21765   unsigned int result;
21766
21767   arg1 = (Dali::Texture *)jarg1;
21768   {
21769     try {
21770       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21771     } catch (std::out_of_range& e) {
21772       {
21773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (std::exception& e) {
21776       {
21777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (...) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21782       };
21783     }
21784   }
21785   jresult = result;
21786   return jresult;
21787 }
21788
21789
21790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21791   unsigned int jresult ;
21792   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21793   unsigned int result;
21794
21795   arg1 = (Dali::Texture *)jarg1;
21796   {
21797     try {
21798       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21799     } catch (std::out_of_range& e) {
21800       {
21801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (std::exception& e) {
21804       {
21805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813   jresult = result;
21814   return jresult;
21815 }
21816
21817
21818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21819   void * jresult ;
21820   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21821   Dali::Texture *result = 0 ;
21822
21823   arg1 = (Dali::Internal::Texture *)jarg1;
21824   {
21825     try {
21826       result = (Dali::Texture *)new Dali::Texture(arg1);
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (...) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21838       };
21839     }
21840   }
21841   jresult = (void *)result;
21842   return jresult;
21843 }
21844
21845
21846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21847   void * jresult ;
21848   Dali::Sampler result;
21849
21850   {
21851     try {
21852       result = Dali::Sampler::New();
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21868   return jresult;
21869 }
21870
21871
21872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21873   void * jresult ;
21874   Dali::Sampler *result = 0 ;
21875
21876   {
21877     try {
21878       result = (Dali::Sampler *)new Dali::Sampler();
21879     } catch (std::out_of_range& e) {
21880       {
21881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (std::exception& e) {
21884       {
21885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893   jresult = (void *)result;
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21899   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21900
21901   arg1 = (Dali::Sampler *)jarg1;
21902   {
21903     try {
21904       delete arg1;
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21912       };
21913     } catch (...) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21916       };
21917     }
21918   }
21919 }
21920
21921
21922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21923   void * jresult ;
21924   Dali::Sampler *arg1 = 0 ;
21925   Dali::Sampler *result = 0 ;
21926
21927   arg1 = (Dali::Sampler *)jarg1;
21928   if (!arg1) {
21929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21930     return 0;
21931   }
21932   {
21933     try {
21934       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21935     } catch (std::out_of_range& e) {
21936       {
21937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (std::exception& e) {
21940       {
21941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21942       };
21943     } catch (...) {
21944       {
21945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21946       };
21947     }
21948   }
21949   jresult = (void *)result;
21950   return jresult;
21951 }
21952
21953
21954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21955   void * jresult ;
21956   Dali::BaseHandle arg1 ;
21957   Dali::BaseHandle *argp1 ;
21958   Dali::Sampler result;
21959
21960   argp1 = (Dali::BaseHandle *)jarg1;
21961   if (!argp1) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21963     return 0;
21964   }
21965   arg1 = *argp1;
21966   {
21967     try {
21968       result = Dali::Sampler::DownCast(arg1);
21969     } catch (std::out_of_range& e) {
21970       {
21971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (std::exception& e) {
21974       {
21975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21976       };
21977     } catch (...) {
21978       {
21979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21980       };
21981     }
21982   }
21983   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21989   void * jresult ;
21990   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21991   Dali::Sampler *arg2 = 0 ;
21992   Dali::Sampler *result = 0 ;
21993
21994   arg1 = (Dali::Sampler *)jarg1;
21995   arg2 = (Dali::Sampler *)jarg2;
21996   if (!arg2) {
21997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21998     return 0;
21999   }
22000   {
22001     try {
22002       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22003     } catch (std::out_of_range& e) {
22004       {
22005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (std::exception& e) {
22008       {
22009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017   jresult = (void *)result;
22018   return jresult;
22019 }
22020
22021
22022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22023   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22024   Dali::FilterMode::Type arg2 ;
22025   Dali::FilterMode::Type arg3 ;
22026
22027   arg1 = (Dali::Sampler *)jarg1;
22028   arg2 = (Dali::FilterMode::Type)jarg2;
22029   arg3 = (Dali::FilterMode::Type)jarg3;
22030   {
22031     try {
22032       (arg1)->SetFilterMode(arg2,arg3);
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22040       };
22041     } catch (...) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22044       };
22045     }
22046   }
22047 }
22048
22049
22050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22051   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22052   Dali::WrapMode::Type arg2 ;
22053   Dali::WrapMode::Type arg3 ;
22054
22055   arg1 = (Dali::Sampler *)jarg1;
22056   arg2 = (Dali::WrapMode::Type)jarg2;
22057   arg3 = (Dali::WrapMode::Type)jarg3;
22058   {
22059     try {
22060       (arg1)->SetWrapMode(arg2,arg3);
22061     } catch (std::out_of_range& e) {
22062       {
22063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22064       };
22065     } catch (std::exception& e) {
22066       {
22067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22068       };
22069     } catch (...) {
22070       {
22071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22072       };
22073     }
22074   }
22075 }
22076
22077
22078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22079   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22080   Dali::WrapMode::Type arg2 ;
22081   Dali::WrapMode::Type arg3 ;
22082   Dali::WrapMode::Type arg4 ;
22083
22084   arg1 = (Dali::Sampler *)jarg1;
22085   arg2 = (Dali::WrapMode::Type)jarg2;
22086   arg3 = (Dali::WrapMode::Type)jarg3;
22087   arg4 = (Dali::WrapMode::Type)jarg4;
22088   {
22089     try {
22090       (arg1)->SetWrapMode(arg2,arg3,arg4);
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22098       };
22099     } catch (...) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22102       };
22103     }
22104   }
22105 }
22106
22107
22108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22109   void * jresult ;
22110   Dali::TextureSet result;
22111
22112   {
22113     try {
22114       result = Dali::TextureSet::New();
22115     } catch (std::out_of_range& e) {
22116       {
22117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22118       };
22119     } catch (std::exception& e) {
22120       {
22121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (...) {
22124       {
22125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22126       };
22127     }
22128   }
22129   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22130   return jresult;
22131 }
22132
22133
22134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22135   void * jresult ;
22136   Dali::TextureSet *result = 0 ;
22137
22138   {
22139     try {
22140       result = (Dali::TextureSet *)new Dali::TextureSet();
22141     } catch (std::out_of_range& e) {
22142       {
22143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (std::exception& e) {
22146       {
22147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155   jresult = (void *)result;
22156   return jresult;
22157 }
22158
22159
22160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22161   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22162
22163   arg1 = (Dali::TextureSet *)jarg1;
22164   {
22165     try {
22166       delete arg1;
22167     } catch (std::out_of_range& e) {
22168       {
22169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22170       };
22171     } catch (std::exception& e) {
22172       {
22173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22174       };
22175     } catch (...) {
22176       {
22177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22178       };
22179     }
22180   }
22181 }
22182
22183
22184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22185   void * jresult ;
22186   Dali::TextureSet *arg1 = 0 ;
22187   Dali::TextureSet *result = 0 ;
22188
22189   arg1 = (Dali::TextureSet *)jarg1;
22190   if (!arg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22192     return 0;
22193   }
22194   {
22195     try {
22196       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22197     } catch (std::out_of_range& e) {
22198       {
22199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22200       };
22201     } catch (std::exception& e) {
22202       {
22203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22204       };
22205     } catch (...) {
22206       {
22207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22208       };
22209     }
22210   }
22211   jresult = (void *)result;
22212   return jresult;
22213 }
22214
22215
22216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22217   void * jresult ;
22218   Dali::BaseHandle arg1 ;
22219   Dali::BaseHandle *argp1 ;
22220   Dali::TextureSet result;
22221
22222   argp1 = (Dali::BaseHandle *)jarg1;
22223   if (!argp1) {
22224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22225     return 0;
22226   }
22227   arg1 = *argp1;
22228   {
22229     try {
22230       result = Dali::TextureSet::DownCast(arg1);
22231     } catch (std::out_of_range& e) {
22232       {
22233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22234       };
22235     } catch (std::exception& e) {
22236       {
22237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22242       };
22243     }
22244   }
22245   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22246   return jresult;
22247 }
22248
22249
22250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22251   void * jresult ;
22252   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22253   Dali::TextureSet *arg2 = 0 ;
22254   Dali::TextureSet *result = 0 ;
22255
22256   arg1 = (Dali::TextureSet *)jarg1;
22257   arg2 = (Dali::TextureSet *)jarg2;
22258   if (!arg2) {
22259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22260     return 0;
22261   }
22262   {
22263     try {
22264       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22265     } catch (std::out_of_range& e) {
22266       {
22267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22268       };
22269     } catch (std::exception& e) {
22270       {
22271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22272       };
22273     } catch (...) {
22274       {
22275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22276       };
22277     }
22278   }
22279   jresult = (void *)result;
22280   return jresult;
22281 }
22282
22283
22284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22285   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22286   size_t arg2 ;
22287   Dali::Texture arg3 ;
22288   Dali::Texture *argp3 ;
22289
22290   arg1 = (Dali::TextureSet *)jarg1;
22291   arg2 = (size_t)jarg2;
22292   argp3 = (Dali::Texture *)jarg3;
22293   if (!argp3) {
22294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22295     return ;
22296   }
22297   arg3 = *argp3;
22298   {
22299     try {
22300       (arg1)->SetTexture(arg2,arg3);
22301     } catch (std::out_of_range& e) {
22302       {
22303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22304       };
22305     } catch (std::exception& e) {
22306       {
22307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22308       };
22309     } catch (...) {
22310       {
22311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22312       };
22313     }
22314   }
22315 }
22316
22317
22318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22319   void * jresult ;
22320   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22321   size_t arg2 ;
22322   Dali::Texture result;
22323
22324   arg1 = (Dali::TextureSet *)jarg1;
22325   arg2 = (size_t)jarg2;
22326   {
22327     try {
22328       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22329     } catch (std::out_of_range& e) {
22330       {
22331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22332       };
22333     } catch (std::exception& e) {
22334       {
22335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22336       };
22337     } catch (...) {
22338       {
22339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22340       };
22341     }
22342   }
22343   jresult = new Dali::Texture((const Dali::Texture &)result);
22344   return jresult;
22345 }
22346
22347
22348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22349   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22350   size_t arg2 ;
22351   Dali::Sampler arg3 ;
22352   Dali::Sampler *argp3 ;
22353
22354   arg1 = (Dali::TextureSet *)jarg1;
22355   arg2 = (size_t)jarg2;
22356   argp3 = (Dali::Sampler *)jarg3;
22357   if (!argp3) {
22358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22359     return ;
22360   }
22361   arg3 = *argp3;
22362   {
22363     try {
22364       (arg1)->SetSampler(arg2,arg3);
22365     } catch (std::out_of_range& e) {
22366       {
22367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22368       };
22369     } catch (std::exception& e) {
22370       {
22371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22372       };
22373     } catch (...) {
22374       {
22375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22376       };
22377     }
22378   }
22379 }
22380
22381
22382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22383   void * jresult ;
22384   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22385   size_t arg2 ;
22386   Dali::Sampler result;
22387
22388   arg1 = (Dali::TextureSet *)jarg1;
22389   arg2 = (size_t)jarg2;
22390   {
22391     try {
22392       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22393     } catch (std::out_of_range& e) {
22394       {
22395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22396       };
22397     } catch (std::exception& e) {
22398       {
22399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (...) {
22402       {
22403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22404       };
22405     }
22406   }
22407   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22408   return jresult;
22409 }
22410
22411
22412 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22413   unsigned long jresult ;
22414   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22415   size_t result;
22416
22417   arg1 = (Dali::TextureSet *)jarg1;
22418   {
22419     try {
22420       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22421     } catch (std::out_of_range& e) {
22422       {
22423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (std::exception& e) {
22426       {
22427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22432       };
22433     }
22434   }
22435   jresult = (unsigned long)result;
22436   return jresult;
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22441   void * jresult ;
22442   Dali::Property::Map *arg1 = 0 ;
22443   Dali::PropertyBuffer result;
22444
22445   arg1 = (Dali::Property::Map *)jarg1;
22446   if (!arg1) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22448     return 0;
22449   }
22450   {
22451     try {
22452       result = Dali::PropertyBuffer::New(*arg1);
22453     } catch (std::out_of_range& e) {
22454       {
22455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22456       };
22457     } catch (std::exception& e) {
22458       {
22459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22460       };
22461     } catch (...) {
22462       {
22463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22464       };
22465     }
22466   }
22467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22473   void * jresult ;
22474   Dali::PropertyBuffer *result = 0 ;
22475
22476   {
22477     try {
22478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22479     } catch (std::out_of_range& e) {
22480       {
22481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (std::exception& e) {
22484       {
22485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493   jresult = (void *)result;
22494   return jresult;
22495 }
22496
22497
22498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22499   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22500
22501   arg1 = (Dali::PropertyBuffer *)jarg1;
22502   {
22503     try {
22504       delete arg1;
22505     } catch (std::out_of_range& e) {
22506       {
22507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22508       };
22509     } catch (std::exception& e) {
22510       {
22511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22516       };
22517     }
22518   }
22519 }
22520
22521
22522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22523   void * jresult ;
22524   Dali::PropertyBuffer *arg1 = 0 ;
22525   Dali::PropertyBuffer *result = 0 ;
22526
22527   arg1 = (Dali::PropertyBuffer *)jarg1;
22528   if (!arg1) {
22529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22530     return 0;
22531   }
22532   {
22533     try {
22534       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22535     } catch (std::out_of_range& e) {
22536       {
22537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22538       };
22539     } catch (std::exception& e) {
22540       {
22541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22542       };
22543     } catch (...) {
22544       {
22545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22546       };
22547     }
22548   }
22549   jresult = (void *)result;
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22555   void * jresult ;
22556   Dali::BaseHandle arg1 ;
22557   Dali::BaseHandle *argp1 ;
22558   Dali::PropertyBuffer result;
22559
22560   argp1 = (Dali::BaseHandle *)jarg1;
22561   if (!argp1) {
22562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22563     return 0;
22564   }
22565   arg1 = *argp1;
22566   {
22567     try {
22568       result = Dali::PropertyBuffer::DownCast(arg1);
22569     } catch (std::out_of_range& e) {
22570       {
22571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22572       };
22573     } catch (std::exception& e) {
22574       {
22575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22576       };
22577     } catch (...) {
22578       {
22579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22580       };
22581     }
22582   }
22583   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22584   return jresult;
22585 }
22586
22587
22588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22589   void * jresult ;
22590   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22591   Dali::PropertyBuffer *arg2 = 0 ;
22592   Dali::PropertyBuffer *result = 0 ;
22593
22594   arg1 = (Dali::PropertyBuffer *)jarg1;
22595   arg2 = (Dali::PropertyBuffer *)jarg2;
22596   if (!arg2) {
22597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22598     return 0;
22599   }
22600   {
22601     try {
22602       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (...) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22614       };
22615     }
22616   }
22617   jresult = (void *)result;
22618   return jresult;
22619 }
22620
22621
22622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22623   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22624   void *arg2 = (void *) 0 ;
22625   std::size_t arg3 ;
22626
22627   arg1 = (Dali::PropertyBuffer *)jarg1;
22628   arg2 = jarg2;
22629   arg3 = (std::size_t)jarg3;
22630   {
22631     try {
22632       (arg1)->SetData((void const *)arg2,arg3);
22633     } catch (std::out_of_range& e) {
22634       {
22635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22636       };
22637     } catch (std::exception& e) {
22638       {
22639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (...) {
22642       {
22643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22644       };
22645     }
22646   }
22647 }
22648
22649
22650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22651   unsigned long jresult ;
22652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22653   std::size_t result;
22654
22655   arg1 = (Dali::PropertyBuffer *)jarg1;
22656   {
22657     try {
22658       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22659     } catch (std::out_of_range& e) {
22660       {
22661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22662       };
22663     } catch (std::exception& e) {
22664       {
22665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22666       };
22667     } catch (...) {
22668       {
22669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22670       };
22671     }
22672   }
22673   jresult = (unsigned long)result;
22674   return jresult;
22675 }
22676
22677
22678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22679   void * jresult ;
22680   Dali::Geometry result;
22681
22682   {
22683     try {
22684       result = Dali::Geometry::New();
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (...) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22696       };
22697     }
22698   }
22699   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22705   void * jresult ;
22706   Dali::Geometry *result = 0 ;
22707
22708   {
22709     try {
22710       result = (Dali::Geometry *)new Dali::Geometry();
22711     } catch (std::out_of_range& e) {
22712       {
22713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22714       };
22715     } catch (std::exception& e) {
22716       {
22717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22718       };
22719     } catch (...) {
22720       {
22721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22722       };
22723     }
22724   }
22725   jresult = (void *)result;
22726   return jresult;
22727 }
22728
22729
22730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22731   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22732
22733   arg1 = (Dali::Geometry *)jarg1;
22734   {
22735     try {
22736       delete arg1;
22737     } catch (std::out_of_range& e) {
22738       {
22739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22740       };
22741     } catch (std::exception& e) {
22742       {
22743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22744       };
22745     } catch (...) {
22746       {
22747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22748       };
22749     }
22750   }
22751 }
22752
22753
22754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22755   void * jresult ;
22756   Dali::Geometry *arg1 = 0 ;
22757   Dali::Geometry *result = 0 ;
22758
22759   arg1 = (Dali::Geometry *)jarg1;
22760   if (!arg1) {
22761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22762     return 0;
22763   }
22764   {
22765     try {
22766       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (...) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22778       };
22779     }
22780   }
22781   jresult = (void *)result;
22782   return jresult;
22783 }
22784
22785
22786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22787   void * jresult ;
22788   Dali::BaseHandle arg1 ;
22789   Dali::BaseHandle *argp1 ;
22790   Dali::Geometry result;
22791
22792   argp1 = (Dali::BaseHandle *)jarg1;
22793   if (!argp1) {
22794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22795     return 0;
22796   }
22797   arg1 = *argp1;
22798   {
22799     try {
22800       result = Dali::Geometry::DownCast(arg1);
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22808       };
22809     } catch (...) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22812       };
22813     }
22814   }
22815   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22816   return jresult;
22817 }
22818
22819
22820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22821   void * jresult ;
22822   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22823   Dali::Geometry *arg2 = 0 ;
22824   Dali::Geometry *result = 0 ;
22825
22826   arg1 = (Dali::Geometry *)jarg1;
22827   arg2 = (Dali::Geometry *)jarg2;
22828   if (!arg2) {
22829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22830     return 0;
22831   }
22832   {
22833     try {
22834       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22835     } catch (std::out_of_range& e) {
22836       {
22837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22838       };
22839     } catch (std::exception& e) {
22840       {
22841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22842       };
22843     } catch (...) {
22844       {
22845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22846       };
22847     }
22848   }
22849   jresult = (void *)result;
22850   return jresult;
22851 }
22852
22853
22854 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22855   unsigned long jresult ;
22856   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22857   Dali::PropertyBuffer *arg2 = 0 ;
22858   std::size_t result;
22859
22860   arg1 = (Dali::Geometry *)jarg1;
22861   arg2 = (Dali::PropertyBuffer *)jarg2;
22862   if (!arg2) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22864     return 0;
22865   }
22866   {
22867     try {
22868       result = (arg1)->AddVertexBuffer(*arg2);
22869     } catch (std::out_of_range& e) {
22870       {
22871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22872       };
22873     } catch (std::exception& e) {
22874       {
22875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22876       };
22877     } catch (...) {
22878       {
22879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22880       };
22881     }
22882   }
22883   jresult = (unsigned long)result;
22884   return jresult;
22885 }
22886
22887
22888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22889   unsigned long jresult ;
22890   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22891   std::size_t result;
22892
22893   arg1 = (Dali::Geometry *)jarg1;
22894   {
22895     try {
22896       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (...) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22908       };
22909     }
22910   }
22911   jresult = (unsigned long)result;
22912   return jresult;
22913 }
22914
22915
22916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22918   std::size_t arg2 ;
22919
22920   arg1 = (Dali::Geometry *)jarg1;
22921   arg2 = (std::size_t)jarg2;
22922   {
22923     try {
22924       (arg1)->RemoveVertexBuffer(arg2);
22925     } catch (std::out_of_range& e) {
22926       {
22927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22928       };
22929     } catch (std::exception& e) {
22930       {
22931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22932       };
22933     } catch (...) {
22934       {
22935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22936       };
22937     }
22938   }
22939 }
22940
22941
22942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22943   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22944   unsigned short *arg2 = (unsigned short *) 0 ;
22945   size_t arg3 ;
22946
22947   arg1 = (Dali::Geometry *)jarg1;
22948   arg2 = jarg2;
22949   arg3 = (size_t)jarg3;
22950   {
22951     try {
22952       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22953     } catch (std::out_of_range& e) {
22954       {
22955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22956       };
22957     } catch (std::exception& e) {
22958       {
22959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22960       };
22961     } catch (...) {
22962       {
22963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22964       };
22965     }
22966   }
22967
22968
22969 }
22970
22971
22972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22973   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22974   Dali::Geometry::Type arg2 ;
22975
22976   arg1 = (Dali::Geometry *)jarg1;
22977   arg2 = (Dali::Geometry::Type)jarg2;
22978   {
22979     try {
22980       (arg1)->SetType(arg2);
22981     } catch (std::out_of_range& e) {
22982       {
22983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22984       };
22985     } catch (std::exception& e) {
22986       {
22987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22988       };
22989     } catch (...) {
22990       {
22991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22992       };
22993     }
22994   }
22995 }
22996
22997
22998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22999   int jresult ;
23000   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
23001   Dali::Geometry::Type result;
23002
23003   arg1 = (Dali::Geometry *)jarg1;
23004   {
23005     try {
23006       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23007     } catch (std::out_of_range& e) {
23008       {
23009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23010       };
23011     } catch (std::exception& e) {
23012       {
23013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23014       };
23015     } catch (...) {
23016       {
23017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23018       };
23019     }
23020   }
23021   jresult = (int)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23027   void * jresult ;
23028   Dali::Shader::Hint *result = 0 ;
23029
23030   {
23031     try {
23032       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23033     } catch (std::out_of_range& e) {
23034       {
23035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23036       };
23037     } catch (std::exception& e) {
23038       {
23039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23040       };
23041     } catch (...) {
23042       {
23043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23044       };
23045     }
23046   }
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23053   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23054
23055   arg1 = (Dali::Shader::Hint *)jarg1;
23056   {
23057     try {
23058       delete arg1;
23059     } catch (std::out_of_range& e) {
23060       {
23061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23062       };
23063     } catch (std::exception& e) {
23064       {
23065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23066       };
23067     } catch (...) {
23068       {
23069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23070       };
23071     }
23072   }
23073 }
23074
23075
23076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23077   int jresult ;
23078   int result;
23079
23080   result = (int)Dali::Shader::Property::PROGRAM;
23081   jresult = (int)result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23087   void * jresult ;
23088   Dali::Shader::Property *result = 0 ;
23089
23090   {
23091     try {
23092       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23093     } catch (std::out_of_range& e) {
23094       {
23095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23096       };
23097     } catch (std::exception& e) {
23098       {
23099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23100       };
23101     } catch (...) {
23102       {
23103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23104       };
23105     }
23106   }
23107   jresult = (void *)result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23113   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23114
23115   arg1 = (Dali::Shader::Property *)jarg1;
23116   {
23117     try {
23118       delete arg1;
23119     } catch (std::out_of_range& e) {
23120       {
23121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23122       };
23123     } catch (std::exception& e) {
23124       {
23125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23126       };
23127     } catch (...) {
23128       {
23129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23130       };
23131     }
23132   }
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23137   void * jresult ;
23138   std::string *arg1 = 0 ;
23139   std::string *arg2 = 0 ;
23140   Dali::Shader::Hint::Value arg3 ;
23141   Dali::Shader result;
23142
23143   if (!jarg1) {
23144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23145     return 0;
23146   }
23147   std::string arg1_str(jarg1);
23148   arg1 = &arg1_str;
23149   if (!jarg2) {
23150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23151     return 0;
23152   }
23153   std::string arg2_str(jarg2);
23154   arg2 = &arg2_str;
23155   arg3 = (Dali::Shader::Hint::Value)jarg3;
23156   {
23157     try {
23158       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23159     } catch (std::out_of_range& e) {
23160       {
23161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23162       };
23163     } catch (std::exception& e) {
23164       {
23165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23166       };
23167     } catch (...) {
23168       {
23169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23170       };
23171     }
23172   }
23173   jresult = new Dali::Shader((const Dali::Shader &)result);
23174
23175   //argout typemap for const std::string&
23176
23177
23178   //argout typemap for const std::string&
23179
23180   return jresult;
23181 }
23182
23183
23184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23185   void * jresult ;
23186   std::string *arg1 = 0 ;
23187   std::string *arg2 = 0 ;
23188   Dali::Shader result;
23189
23190   if (!jarg1) {
23191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23192     return 0;
23193   }
23194   std::string arg1_str(jarg1);
23195   arg1 = &arg1_str;
23196   if (!jarg2) {
23197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23198     return 0;
23199   }
23200   std::string arg2_str(jarg2);
23201   arg2 = &arg2_str;
23202   {
23203     try {
23204       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23205     } catch (std::out_of_range& e) {
23206       {
23207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23208       };
23209     } catch (std::exception& e) {
23210       {
23211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23212       };
23213     } catch (...) {
23214       {
23215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23216       };
23217     }
23218   }
23219   jresult = new Dali::Shader((const Dali::Shader &)result);
23220
23221   //argout typemap for const std::string&
23222
23223
23224   //argout typemap for const std::string&
23225
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23231   void * jresult ;
23232   Dali::Shader *result = 0 ;
23233
23234   {
23235     try {
23236       result = (Dali::Shader *)new Dali::Shader();
23237     } catch (std::out_of_range& e) {
23238       {
23239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23240       };
23241     } catch (std::exception& e) {
23242       {
23243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23244       };
23245     } catch (...) {
23246       {
23247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23248       };
23249     }
23250   }
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23257   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23258
23259   arg1 = (Dali::Shader *)jarg1;
23260   {
23261     try {
23262       delete arg1;
23263     } catch (std::out_of_range& e) {
23264       {
23265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23266       };
23267     } catch (std::exception& e) {
23268       {
23269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23270       };
23271     } catch (...) {
23272       {
23273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23274       };
23275     }
23276   }
23277 }
23278
23279
23280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23281   void * jresult ;
23282   Dali::Shader *arg1 = 0 ;
23283   Dali::Shader *result = 0 ;
23284
23285   arg1 = (Dali::Shader *)jarg1;
23286   if (!arg1) {
23287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23288     return 0;
23289   }
23290   {
23291     try {
23292       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23293     } catch (std::out_of_range& e) {
23294       {
23295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23296       };
23297     } catch (std::exception& e) {
23298       {
23299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23300       };
23301     } catch (...) {
23302       {
23303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23304       };
23305     }
23306   }
23307   jresult = (void *)result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23313   void * jresult ;
23314   Dali::BaseHandle arg1 ;
23315   Dali::BaseHandle *argp1 ;
23316   Dali::Shader result;
23317
23318   argp1 = (Dali::BaseHandle *)jarg1;
23319   if (!argp1) {
23320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23321     return 0;
23322   }
23323   arg1 = *argp1;
23324   {
23325     try {
23326       result = Dali::Shader::DownCast(arg1);
23327     } catch (std::out_of_range& e) {
23328       {
23329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23330       };
23331     } catch (std::exception& e) {
23332       {
23333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23334       };
23335     } catch (...) {
23336       {
23337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23338       };
23339     }
23340   }
23341   jresult = new Dali::Shader((const Dali::Shader &)result);
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23347   void * jresult ;
23348   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23349   Dali::Shader *arg2 = 0 ;
23350   Dali::Shader *result = 0 ;
23351
23352   arg1 = (Dali::Shader *)jarg1;
23353   arg2 = (Dali::Shader *)jarg2;
23354   if (!arg2) {
23355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23356     return 0;
23357   }
23358   {
23359     try {
23360       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23361     } catch (std::out_of_range& e) {
23362       {
23363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23364       };
23365     } catch (std::exception& e) {
23366       {
23367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23368       };
23369     } catch (...) {
23370       {
23371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23372       };
23373     }
23374   }
23375   jresult = (void *)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::BLEND_MODE;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23521   int jresult ;
23522   int result;
23523
23524   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23525   jresult = (int)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23531   int jresult ;
23532   int result;
23533
23534   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23535   jresult = (int)result;
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23541   int jresult ;
23542   int result;
23543
23544   result = (int)Dali::Renderer::Property::RENDER_MODE;
23545   jresult = (int)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23551   int jresult ;
23552   int result;
23553
23554   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23555   jresult = (int)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23561   int jresult ;
23562   int result;
23563
23564   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23565   jresult = (int)result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23571   int jresult ;
23572   int result;
23573
23574   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23575   jresult = (int)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23581   int jresult ;
23582   int result;
23583
23584   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23591   int jresult ;
23592   int result;
23593
23594   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23601   int jresult ;
23602   int result;
23603
23604   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23605   jresult = (int)result;
23606   return jresult;
23607 }
23608
23609
23610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23611   int jresult ;
23612   int result;
23613
23614   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23615   jresult = (int)result;
23616   return jresult;
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23621   void * jresult ;
23622   Dali::Renderer::Property *result = 0 ;
23623
23624   {
23625     try {
23626       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23627     } catch (std::out_of_range& e) {
23628       {
23629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23630       };
23631     } catch (std::exception& e) {
23632       {
23633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (...) {
23636       {
23637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23638       };
23639     }
23640   }
23641   jresult = (void *)result;
23642   return jresult;
23643 }
23644
23645
23646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23647   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23648
23649   arg1 = (Dali::Renderer::Property *)jarg1;
23650   {
23651     try {
23652       delete arg1;
23653     } catch (std::out_of_range& e) {
23654       {
23655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23656       };
23657     } catch (std::exception& e) {
23658       {
23659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23660       };
23661     } catch (...) {
23662       {
23663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23664       };
23665     }
23666   }
23667 }
23668
23669
23670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23671   void * jresult ;
23672   Dali::Geometry *arg1 = 0 ;
23673   Dali::Shader *arg2 = 0 ;
23674   Dali::Renderer result;
23675
23676   arg1 = (Dali::Geometry *)jarg1;
23677   if (!arg1) {
23678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23679     return 0;
23680   }
23681   arg2 = (Dali::Shader *)jarg2;
23682   if (!arg2) {
23683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23684     return 0;
23685   }
23686   {
23687     try {
23688       result = Dali::Renderer::New(*arg1,*arg2);
23689     } catch (std::out_of_range& e) {
23690       {
23691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23692       };
23693     } catch (std::exception& e) {
23694       {
23695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23700       };
23701     }
23702   }
23703   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23704   return jresult;
23705 }
23706
23707
23708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23709   void * jresult ;
23710   Dali::Renderer *result = 0 ;
23711
23712   {
23713     try {
23714       result = (Dali::Renderer *)new Dali::Renderer();
23715     } catch (std::out_of_range& e) {
23716       {
23717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (std::exception& e) {
23720       {
23721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729   jresult = (void *)result;
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23735   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23736
23737   arg1 = (Dali::Renderer *)jarg1;
23738   {
23739     try {
23740       delete arg1;
23741     } catch (std::out_of_range& e) {
23742       {
23743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23744       };
23745     } catch (std::exception& e) {
23746       {
23747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23748       };
23749     } catch (...) {
23750       {
23751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23752       };
23753     }
23754   }
23755 }
23756
23757
23758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23759   void * jresult ;
23760   Dali::Renderer *arg1 = 0 ;
23761   Dali::Renderer *result = 0 ;
23762
23763   arg1 = (Dali::Renderer *)jarg1;
23764   if (!arg1) {
23765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23766     return 0;
23767   }
23768   {
23769     try {
23770       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (...) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23782       };
23783     }
23784   }
23785   jresult = (void *)result;
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23791   void * jresult ;
23792   Dali::BaseHandle arg1 ;
23793   Dali::BaseHandle *argp1 ;
23794   Dali::Renderer result;
23795
23796   argp1 = (Dali::BaseHandle *)jarg1;
23797   if (!argp1) {
23798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23799     return 0;
23800   }
23801   arg1 = *argp1;
23802   {
23803     try {
23804       result = Dali::Renderer::DownCast(arg1);
23805     } catch (std::out_of_range& e) {
23806       {
23807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23808       };
23809     } catch (std::exception& e) {
23810       {
23811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (...) {
23814       {
23815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23816       };
23817     }
23818   }
23819   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23820   return jresult;
23821 }
23822
23823
23824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23825   void * jresult ;
23826   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23827   Dali::Renderer *arg2 = 0 ;
23828   Dali::Renderer *result = 0 ;
23829
23830   arg1 = (Dali::Renderer *)jarg1;
23831   arg2 = (Dali::Renderer *)jarg2;
23832   if (!arg2) {
23833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23834     return 0;
23835   }
23836   {
23837     try {
23838       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23839     } catch (std::out_of_range& e) {
23840       {
23841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23842       };
23843     } catch (std::exception& e) {
23844       {
23845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23846       };
23847     } catch (...) {
23848       {
23849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23850       };
23851     }
23852   }
23853   jresult = (void *)result;
23854   return jresult;
23855 }
23856
23857
23858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23859   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23860   Dali::Geometry *arg2 = 0 ;
23861
23862   arg1 = (Dali::Renderer *)jarg1;
23863   arg2 = (Dali::Geometry *)jarg2;
23864   if (!arg2) {
23865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23866     return ;
23867   }
23868   {
23869     try {
23870       (arg1)->SetGeometry(*arg2);
23871     } catch (std::out_of_range& e) {
23872       {
23873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23874       };
23875     } catch (std::exception& e) {
23876       {
23877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23878       };
23879     } catch (...) {
23880       {
23881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23882       };
23883     }
23884   }
23885 }
23886
23887
23888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23889   void * jresult ;
23890   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23891   Dali::Geometry result;
23892
23893   arg1 = (Dali::Renderer *)jarg1;
23894   {
23895     try {
23896       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23897     } catch (std::out_of_range& e) {
23898       {
23899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (std::exception& e) {
23902       {
23903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (...) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23908       };
23909     }
23910   }
23911   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23917   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23918   int arg2 ;
23919   int arg3 ;
23920
23921   arg1 = (Dali::Renderer *)jarg1;
23922   arg2 = (int)jarg2;
23923   arg3 = (int)jarg3;
23924   {
23925     try {
23926       (arg1)->SetIndexRange(arg2,arg3);
23927     } catch (std::out_of_range& e) {
23928       {
23929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23930       };
23931     } catch (std::exception& e) {
23932       {
23933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23934       };
23935     } catch (...) {
23936       {
23937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23938       };
23939     }
23940   }
23941 }
23942
23943
23944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23945   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23946   Dali::TextureSet *arg2 = 0 ;
23947
23948   arg1 = (Dali::Renderer *)jarg1;
23949   arg2 = (Dali::TextureSet *)jarg2;
23950   if (!arg2) {
23951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23952     return ;
23953   }
23954   {
23955     try {
23956       (arg1)->SetTextures(*arg2);
23957     } catch (std::out_of_range& e) {
23958       {
23959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23960       };
23961     } catch (std::exception& e) {
23962       {
23963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23964       };
23965     } catch (...) {
23966       {
23967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23968       };
23969     }
23970   }
23971 }
23972
23973
23974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23975   void * jresult ;
23976   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23977   Dali::TextureSet result;
23978
23979   arg1 = (Dali::Renderer *)jarg1;
23980   {
23981     try {
23982       result = ((Dali::Renderer const *)arg1)->GetTextures();
23983     } catch (std::out_of_range& e) {
23984       {
23985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23986       };
23987     } catch (std::exception& e) {
23988       {
23989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23990       };
23991     } catch (...) {
23992       {
23993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23994       };
23995     }
23996   }
23997   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23998   return jresult;
23999 }
24000
24001
24002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24003   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24004   Dali::Shader *arg2 = 0 ;
24005
24006   arg1 = (Dali::Renderer *)jarg1;
24007   arg2 = (Dali::Shader *)jarg2;
24008   if (!arg2) {
24009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24010     return ;
24011   }
24012   {
24013     try {
24014       (arg1)->SetShader(*arg2);
24015     } catch (std::out_of_range& e) {
24016       {
24017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24018       };
24019     } catch (std::exception& e) {
24020       {
24021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24022       };
24023     } catch (...) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24026       };
24027     }
24028   }
24029 }
24030
24031
24032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24033   void * jresult ;
24034   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24035   Dali::Shader result;
24036
24037   arg1 = (Dali::Renderer *)jarg1;
24038   {
24039     try {
24040       result = ((Dali::Renderer const *)arg1)->GetShader();
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24048       };
24049     } catch (...) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24052       };
24053     }
24054   }
24055   jresult = new Dali::Shader((const Dali::Shader &)result);
24056   return jresult;
24057 }
24058
24059
24060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24061   void * jresult ;
24062   Dali::FrameBuffer::Attachment *result = 0 ;
24063
24064   {
24065     try {
24066       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24067     } catch (std::out_of_range& e) {
24068       {
24069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24070       };
24071     } catch (std::exception& e) {
24072       {
24073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24074       };
24075     } catch (...) {
24076       {
24077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24078       };
24079     }
24080   }
24081   jresult = (void *)result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24087   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24088
24089   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24090   {
24091     try {
24092       delete arg1;
24093     } catch (std::out_of_range& e) {
24094       {
24095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24096       };
24097     } catch (std::exception& e) {
24098       {
24099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24104       };
24105     }
24106   }
24107 }
24108
24109
24110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24111   void * jresult ;
24112   unsigned int arg1 ;
24113   unsigned int arg2 ;
24114   unsigned int arg3 ;
24115   Dali::FrameBuffer result;
24116
24117   arg1 = (unsigned int)jarg1;
24118   arg2 = (unsigned int)jarg2;
24119   arg3 = (unsigned int)jarg3;
24120   {
24121     try {
24122       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24123     } catch (std::out_of_range& e) {
24124       {
24125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (std::exception& e) {
24128       {
24129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24143   void * jresult ;
24144   Dali::FrameBuffer *result = 0 ;
24145
24146   {
24147     try {
24148       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24149     } catch (std::out_of_range& e) {
24150       {
24151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24152       };
24153     } catch (std::exception& e) {
24154       {
24155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (...) {
24158       {
24159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24160       };
24161     }
24162   }
24163   jresult = (void *)result;
24164   return jresult;
24165 }
24166
24167
24168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24169   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24170
24171   arg1 = (Dali::FrameBuffer *)jarg1;
24172   {
24173     try {
24174       delete arg1;
24175     } catch (std::out_of_range& e) {
24176       {
24177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24178       };
24179     } catch (std::exception& e) {
24180       {
24181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24182       };
24183     } catch (...) {
24184       {
24185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24186       };
24187     }
24188   }
24189 }
24190
24191
24192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24193   void * jresult ;
24194   Dali::FrameBuffer *arg1 = 0 ;
24195   Dali::FrameBuffer *result = 0 ;
24196
24197   arg1 = (Dali::FrameBuffer *)jarg1;
24198   if (!arg1) {
24199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24200     return 0;
24201   }
24202   {
24203     try {
24204       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24205     } catch (std::out_of_range& e) {
24206       {
24207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24208       };
24209     } catch (std::exception& e) {
24210       {
24211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24212       };
24213     } catch (...) {
24214       {
24215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24216       };
24217     }
24218   }
24219   jresult = (void *)result;
24220   return jresult;
24221 }
24222
24223
24224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24225   void * jresult ;
24226   Dali::BaseHandle arg1 ;
24227   Dali::BaseHandle *argp1 ;
24228   Dali::FrameBuffer result;
24229
24230   argp1 = (Dali::BaseHandle *)jarg1;
24231   if (!argp1) {
24232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24233     return 0;
24234   }
24235   arg1 = *argp1;
24236   {
24237     try {
24238       result = Dali::FrameBuffer::DownCast(arg1);
24239     } catch (std::out_of_range& e) {
24240       {
24241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (std::exception& e) {
24244       {
24245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24250       };
24251     }
24252   }
24253   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24259   void * jresult ;
24260   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24261   Dali::FrameBuffer *arg2 = 0 ;
24262   Dali::FrameBuffer *result = 0 ;
24263
24264   arg1 = (Dali::FrameBuffer *)jarg1;
24265   arg2 = (Dali::FrameBuffer *)jarg2;
24266   if (!arg2) {
24267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24268     return 0;
24269   }
24270   {
24271     try {
24272       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24273     } catch (std::out_of_range& e) {
24274       {
24275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (std::exception& e) {
24278       {
24279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (...) {
24282       {
24283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24284       };
24285     }
24286   }
24287   jresult = (void *)result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24293   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24294   Dali::Texture *arg2 = 0 ;
24295
24296   arg1 = (Dali::FrameBuffer *)jarg1;
24297   arg2 = (Dali::Texture *)jarg2;
24298   if (!arg2) {
24299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24300     return ;
24301   }
24302   {
24303     try {
24304       (arg1)->AttachColorTexture(*arg2);
24305     } catch (std::out_of_range& e) {
24306       {
24307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24308       };
24309     } catch (std::exception& e) {
24310       {
24311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24312       };
24313     } catch (...) {
24314       {
24315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24316       };
24317     }
24318   }
24319 }
24320
24321
24322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24323   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24324   Dali::Texture *arg2 = 0 ;
24325   unsigned int arg3 ;
24326   unsigned int arg4 ;
24327
24328   arg1 = (Dali::FrameBuffer *)jarg1;
24329   arg2 = (Dali::Texture *)jarg2;
24330   if (!arg2) {
24331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24332     return ;
24333   }
24334   arg3 = (unsigned int)jarg3;
24335   arg4 = (unsigned int)jarg4;
24336   {
24337     try {
24338       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24339     } catch (std::out_of_range& e) {
24340       {
24341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24342       };
24343     } catch (std::exception& e) {
24344       {
24345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24346       };
24347     } catch (...) {
24348       {
24349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24350       };
24351     }
24352   }
24353 }
24354
24355
24356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24357   void * jresult ;
24358   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24359   Dali::Texture result;
24360
24361   arg1 = (Dali::FrameBuffer *)jarg1;
24362   {
24363     try {
24364       result = (arg1)->GetColorTexture();
24365     } catch (std::out_of_range& e) {
24366       {
24367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24368       };
24369     } catch (std::exception& e) {
24370       {
24371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24372       };
24373     } catch (...) {
24374       {
24375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24376       };
24377     }
24378   }
24379   jresult = new Dali::Texture((const Dali::Texture &)result);
24380   return jresult;
24381 }
24382
24383
24384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24385   void * jresult ;
24386   Dali::RenderTaskList *result = 0 ;
24387
24388   {
24389     try {
24390       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24391     } catch (std::out_of_range& e) {
24392       {
24393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (std::exception& e) {
24396       {
24397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24398       };
24399     } catch (...) {
24400       {
24401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24402       };
24403     }
24404   }
24405   jresult = (void *)result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24411   void * jresult ;
24412   Dali::BaseHandle arg1 ;
24413   Dali::BaseHandle *argp1 ;
24414   Dali::RenderTaskList result;
24415
24416   argp1 = (Dali::BaseHandle *)jarg1;
24417   if (!argp1) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24419     return 0;
24420   }
24421   arg1 = *argp1;
24422   {
24423     try {
24424       result = Dali::RenderTaskList::DownCast(arg1);
24425     } catch (std::out_of_range& e) {
24426       {
24427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24428       };
24429     } catch (std::exception& e) {
24430       {
24431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24432       };
24433     } catch (...) {
24434       {
24435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24436       };
24437     }
24438   }
24439   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24440   return jresult;
24441 }
24442
24443
24444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24445   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24446
24447   arg1 = (Dali::RenderTaskList *)jarg1;
24448   {
24449     try {
24450       delete arg1;
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24458       };
24459     } catch (...) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24462       };
24463     }
24464   }
24465 }
24466
24467
24468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24469   void * jresult ;
24470   Dali::RenderTaskList *arg1 = 0 ;
24471   Dali::RenderTaskList *result = 0 ;
24472
24473   arg1 = (Dali::RenderTaskList *)jarg1;
24474   if (!arg1) {
24475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24476     return 0;
24477   }
24478   {
24479     try {
24480       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24481     } catch (std::out_of_range& e) {
24482       {
24483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (std::exception& e) {
24486       {
24487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24488       };
24489     } catch (...) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24492       };
24493     }
24494   }
24495   jresult = (void *)result;
24496   return jresult;
24497 }
24498
24499
24500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24501   void * jresult ;
24502   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24503   Dali::RenderTaskList *arg2 = 0 ;
24504   Dali::RenderTaskList *result = 0 ;
24505
24506   arg1 = (Dali::RenderTaskList *)jarg1;
24507   arg2 = (Dali::RenderTaskList *)jarg2;
24508   if (!arg2) {
24509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24510     return 0;
24511   }
24512   {
24513     try {
24514       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24515     } catch (std::out_of_range& e) {
24516       {
24517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24518       };
24519     } catch (std::exception& e) {
24520       {
24521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (...) {
24524       {
24525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24526       };
24527     }
24528   }
24529   jresult = (void *)result;
24530   return jresult;
24531 }
24532
24533
24534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24535   void * jresult ;
24536   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24537   Dali::RenderTask result;
24538
24539   arg1 = (Dali::RenderTaskList *)jarg1;
24540   {
24541     try {
24542       result = (arg1)->CreateTask();
24543     } catch (std::out_of_range& e) {
24544       {
24545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24546       };
24547     } catch (std::exception& e) {
24548       {
24549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24550       };
24551     } catch (...) {
24552       {
24553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24554       };
24555     }
24556   }
24557   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24558   return jresult;
24559 }
24560
24561
24562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24563   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24564   Dali::RenderTask arg2 ;
24565   Dali::RenderTask *argp2 ;
24566
24567   arg1 = (Dali::RenderTaskList *)jarg1;
24568   argp2 = (Dali::RenderTask *)jarg2;
24569   if (!argp2) {
24570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24571     return ;
24572   }
24573   arg2 = *argp2;
24574   {
24575     try {
24576       (arg1)->RemoveTask(arg2);
24577     } catch (std::out_of_range& e) {
24578       {
24579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24580       };
24581     } catch (std::exception& e) {
24582       {
24583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24588       };
24589     }
24590   }
24591 }
24592
24593
24594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24595   unsigned int jresult ;
24596   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24597   unsigned int result;
24598
24599   arg1 = (Dali::RenderTaskList *)jarg1;
24600   {
24601     try {
24602       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24603     } catch (std::out_of_range& e) {
24604       {
24605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24606       };
24607     } catch (std::exception& e) {
24608       {
24609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24610       };
24611     } catch (...) {
24612       {
24613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24614       };
24615     }
24616   }
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621
24622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24623   void * jresult ;
24624   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24625   unsigned int arg2 ;
24626   Dali::RenderTask result;
24627
24628   arg1 = (Dali::RenderTaskList *)jarg1;
24629   arg2 = (unsigned int)jarg2;
24630   {
24631     try {
24632       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24633     } catch (std::out_of_range& e) {
24634       {
24635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (std::exception& e) {
24638       {
24639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24640       };
24641     } catch (...) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24644       };
24645     }
24646   }
24647   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24653   int jresult ;
24654   int result;
24655
24656   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24657   jresult = (int)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24663   int jresult ;
24664   int result;
24665
24666   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24667   jresult = (int)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24673   int jresult ;
24674   int result;
24675
24676   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24677   jresult = (int)result;
24678   return jresult;
24679 }
24680
24681
24682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24683   int jresult ;
24684   int result;
24685
24686   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24687   jresult = (int)result;
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24693   void * jresult ;
24694   Dali::RenderTask::Property *result = 0 ;
24695
24696   {
24697     try {
24698       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24699     } catch (std::out_of_range& e) {
24700       {
24701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24702       };
24703     } catch (std::exception& e) {
24704       {
24705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24706       };
24707     } catch (...) {
24708       {
24709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24710       };
24711     }
24712   }
24713   jresult = (void *)result;
24714   return jresult;
24715 }
24716
24717
24718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24719   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24720
24721   arg1 = (Dali::RenderTask::Property *)jarg1;
24722   {
24723     try {
24724       delete arg1;
24725     } catch (std::out_of_range& e) {
24726       {
24727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24728       };
24729     } catch (std::exception& e) {
24730       {
24731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24736       };
24737     }
24738   }
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24743   void * jresult ;
24744   bool (*result)(Dali::Vector2 &) = 0 ;
24745
24746   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24747   jresult = (void *)result;
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24753   void * jresult ;
24754   bool (*result)(Dali::Vector2 &) = 0 ;
24755
24756   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24757   jresult = (void *)result;
24758   return jresult;
24759 }
24760
24761
24762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24763   unsigned int jresult ;
24764   bool result;
24765
24766   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24767   jresult = result;
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24773   unsigned int jresult ;
24774   bool result;
24775
24776   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24783   void * jresult ;
24784   Dali::Vector4 *result = 0 ;
24785
24786   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24787   jresult = (void *)result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24793   unsigned int jresult ;
24794   bool result;
24795
24796   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24797   jresult = result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24803   unsigned int jresult ;
24804   bool result;
24805
24806   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24807   jresult = result;
24808   return jresult;
24809 }
24810
24811
24812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24813   unsigned int jresult ;
24814   unsigned int result;
24815
24816   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24817   jresult = result;
24818   return jresult;
24819 }
24820
24821
24822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24823   void * jresult ;
24824   Dali::RenderTask *result = 0 ;
24825
24826   {
24827     try {
24828       result = (Dali::RenderTask *)new Dali::RenderTask();
24829     } catch (std::out_of_range& e) {
24830       {
24831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24832       };
24833     } catch (std::exception& e) {
24834       {
24835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24836       };
24837     } catch (...) {
24838       {
24839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24840       };
24841     }
24842   }
24843   jresult = (void *)result;
24844   return jresult;
24845 }
24846
24847
24848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24849   void * jresult ;
24850   Dali::BaseHandle arg1 ;
24851   Dali::BaseHandle *argp1 ;
24852   Dali::RenderTask result;
24853
24854   argp1 = (Dali::BaseHandle *)jarg1;
24855   if (!argp1) {
24856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24857     return 0;
24858   }
24859   arg1 = *argp1;
24860   {
24861     try {
24862       result = Dali::RenderTask::DownCast(arg1);
24863     } catch (std::out_of_range& e) {
24864       {
24865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24866       };
24867     } catch (std::exception& e) {
24868       {
24869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24870       };
24871     } catch (...) {
24872       {
24873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24874       };
24875     }
24876   }
24877   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24878   return jresult;
24879 }
24880
24881
24882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24883   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24884
24885   arg1 = (Dali::RenderTask *)jarg1;
24886   {
24887     try {
24888       delete arg1;
24889     } catch (std::out_of_range& e) {
24890       {
24891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24892       };
24893     } catch (std::exception& e) {
24894       {
24895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24900       };
24901     }
24902   }
24903 }
24904
24905
24906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24907   void * jresult ;
24908   Dali::RenderTask *arg1 = 0 ;
24909   Dali::RenderTask *result = 0 ;
24910
24911   arg1 = (Dali::RenderTask *)jarg1;
24912   if (!arg1) {
24913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24914     return 0;
24915   }
24916   {
24917     try {
24918       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (...) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24930       };
24931     }
24932   }
24933   jresult = (void *)result;
24934   return jresult;
24935 }
24936
24937
24938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24939   void * jresult ;
24940   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24941   Dali::RenderTask *arg2 = 0 ;
24942   Dali::RenderTask *result = 0 ;
24943
24944   arg1 = (Dali::RenderTask *)jarg1;
24945   arg2 = (Dali::RenderTask *)jarg2;
24946   if (!arg2) {
24947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24948     return 0;
24949   }
24950   {
24951     try {
24952       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24953     } catch (std::out_of_range& e) {
24954       {
24955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24956       };
24957     } catch (std::exception& e) {
24958       {
24959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24960       };
24961     } catch (...) {
24962       {
24963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24964       };
24965     }
24966   }
24967   jresult = (void *)result;
24968   return jresult;
24969 }
24970
24971
24972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24973   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24974   Dali::Actor arg2 ;
24975   Dali::Actor *argp2 ;
24976
24977   arg1 = (Dali::RenderTask *)jarg1;
24978   argp2 = (Dali::Actor *)jarg2;
24979   if (!argp2) {
24980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24981     return ;
24982   }
24983   arg2 = *argp2;
24984   {
24985     try {
24986       (arg1)->SetSourceActor(arg2);
24987     } catch (std::out_of_range& e) {
24988       {
24989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24990       };
24991     } catch (std::exception& e) {
24992       {
24993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24998       };
24999     }
25000   }
25001 }
25002
25003
25004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25005   void * jresult ;
25006   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25007   Dali::Actor result;
25008
25009   arg1 = (Dali::RenderTask *)jarg1;
25010   {
25011     try {
25012       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25013     } catch (std::out_of_range& e) {
25014       {
25015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25016       };
25017     } catch (std::exception& e) {
25018       {
25019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25020       };
25021     } catch (...) {
25022       {
25023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25024       };
25025     }
25026   }
25027   jresult = new Dali::Actor((const Dali::Actor &)result);
25028   return jresult;
25029 }
25030
25031
25032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25033   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25034   bool arg2 ;
25035
25036   arg1 = (Dali::RenderTask *)jarg1;
25037   arg2 = jarg2 ? true : false;
25038   {
25039     try {
25040       (arg1)->SetExclusive(arg2);
25041     } catch (std::out_of_range& e) {
25042       {
25043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25044       };
25045     } catch (std::exception& e) {
25046       {
25047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25048       };
25049     } catch (...) {
25050       {
25051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25052       };
25053     }
25054   }
25055 }
25056
25057
25058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25059   unsigned int jresult ;
25060   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25061   bool result;
25062
25063   arg1 = (Dali::RenderTask *)jarg1;
25064   {
25065     try {
25066       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25067     } catch (std::out_of_range& e) {
25068       {
25069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25070       };
25071     } catch (std::exception& e) {
25072       {
25073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25074       };
25075     } catch (...) {
25076       {
25077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25078       };
25079     }
25080   }
25081   jresult = result;
25082   return jresult;
25083 }
25084
25085
25086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25087   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25088   bool arg2 ;
25089
25090   arg1 = (Dali::RenderTask *)jarg1;
25091   arg2 = jarg2 ? true : false;
25092   {
25093     try {
25094       (arg1)->SetInputEnabled(arg2);
25095     } catch (std::out_of_range& e) {
25096       {
25097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25098       };
25099     } catch (std::exception& e) {
25100       {
25101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25102       };
25103     } catch (...) {
25104       {
25105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25106       };
25107     }
25108   }
25109 }
25110
25111
25112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25113   unsigned int jresult ;
25114   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25115   bool result;
25116
25117   arg1 = (Dali::RenderTask *)jarg1;
25118   {
25119     try {
25120       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25132       };
25133     }
25134   }
25135   jresult = result;
25136   return jresult;
25137 }
25138
25139
25140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25141   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25142   Dali::CameraActor arg2 ;
25143   Dali::CameraActor *argp2 ;
25144
25145   arg1 = (Dali::RenderTask *)jarg1;
25146   argp2 = (Dali::CameraActor *)jarg2;
25147   if (!argp2) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25149     return ;
25150   }
25151   arg2 = *argp2;
25152   {
25153     try {
25154       (arg1)->SetCameraActor(arg2);
25155     } catch (std::out_of_range& e) {
25156       {
25157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25158       };
25159     } catch (std::exception& e) {
25160       {
25161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25162       };
25163     } catch (...) {
25164       {
25165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25166       };
25167     }
25168   }
25169 }
25170
25171
25172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25173   void * jresult ;
25174   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25175   Dali::CameraActor result;
25176
25177   arg1 = (Dali::RenderTask *)jarg1;
25178   {
25179     try {
25180       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25181     } catch (std::out_of_range& e) {
25182       {
25183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25184       };
25185     } catch (std::exception& e) {
25186       {
25187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25188       };
25189     } catch (...) {
25190       {
25191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25192       };
25193     }
25194   }
25195   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25196   return jresult;
25197 }
25198
25199
25200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25201   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25202   Dali::FrameBufferImage arg2 ;
25203   Dali::FrameBufferImage *argp2 ;
25204
25205   arg1 = (Dali::RenderTask *)jarg1;
25206   argp2 = (Dali::FrameBufferImage *)jarg2;
25207   if (!argp2) {
25208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25209     return ;
25210   }
25211   arg2 = *argp2;
25212   {
25213     try {
25214       (arg1)->SetTargetFrameBuffer(arg2);
25215     } catch (std::out_of_range& e) {
25216       {
25217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25218       };
25219     } catch (std::exception& e) {
25220       {
25221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25222       };
25223     } catch (...) {
25224       {
25225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25226       };
25227     }
25228   }
25229 }
25230
25231
25232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25233   void * jresult ;
25234   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25235   Dali::FrameBufferImage result;
25236
25237   arg1 = (Dali::RenderTask *)jarg1;
25238   {
25239     try {
25240       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25241     } catch (std::out_of_range& e) {
25242       {
25243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25244       };
25245     } catch (std::exception& e) {
25246       {
25247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25248       };
25249     } catch (...) {
25250       {
25251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25252       };
25253     }
25254   }
25255   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25256   return jresult;
25257 }
25258
25259
25260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25261   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25262   Dali::FrameBuffer arg2 ;
25263   Dali::FrameBuffer *argp2 ;
25264
25265   arg1 = (Dali::RenderTask *)jarg1;
25266   argp2 = (Dali::FrameBuffer *)jarg2;
25267   if (!argp2) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25269     return ;
25270   }
25271   arg2 = *argp2;
25272   {
25273     try {
25274       (arg1)->SetFrameBuffer(arg2);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289 }
25290
25291
25292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25293   void * jresult ;
25294   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25295   Dali::FrameBuffer result;
25296
25297   arg1 = (Dali::RenderTask *)jarg1;
25298   {
25299     try {
25300       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25301     } catch (std::out_of_range& e) {
25302       {
25303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25304       };
25305     } catch (std::exception& e) {
25306       {
25307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (...) {
25310       {
25311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25312       };
25313     }
25314   }
25315   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25316   return jresult;
25317 }
25318
25319
25320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25321   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25322   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25323
25324   arg1 = (Dali::RenderTask *)jarg1;
25325   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25326   {
25327     try {
25328       (arg1)->SetScreenToFrameBufferFunction(arg2);
25329     } catch (std::out_of_range& e) {
25330       {
25331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25332       };
25333     } catch (std::exception& e) {
25334       {
25335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25336       };
25337     } catch (...) {
25338       {
25339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25340       };
25341     }
25342   }
25343 }
25344
25345
25346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25347   void * jresult ;
25348   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25349   Dali::RenderTask::ScreenToFrameBufferFunction result;
25350
25351   arg1 = (Dali::RenderTask *)jarg1;
25352   {
25353     try {
25354       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25355     } catch (std::out_of_range& e) {
25356       {
25357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25358       };
25359     } catch (std::exception& e) {
25360       {
25361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25362       };
25363     } catch (...) {
25364       {
25365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25366       };
25367     }
25368   }
25369   jresult = (void *)result;
25370   return jresult;
25371 }
25372
25373
25374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25376   Dali::Actor arg2 ;
25377   Dali::Actor *argp2 ;
25378
25379   arg1 = (Dali::RenderTask *)jarg1;
25380   argp2 = (Dali::Actor *)jarg2;
25381   if (!argp2) {
25382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25383     return ;
25384   }
25385   arg2 = *argp2;
25386   {
25387     try {
25388       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25389     } catch (std::out_of_range& e) {
25390       {
25391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25392       };
25393     } catch (std::exception& e) {
25394       {
25395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25396       };
25397     } catch (...) {
25398       {
25399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25400       };
25401     }
25402   }
25403 }
25404
25405
25406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25407   void * jresult ;
25408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25409   Dali::Actor result;
25410
25411   arg1 = (Dali::RenderTask *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429   jresult = new Dali::Actor((const Dali::Actor &)result);
25430   return jresult;
25431 }
25432
25433
25434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25436   Dali::Vector2 arg2 ;
25437   Dali::Vector2 *argp2 ;
25438
25439   arg1 = (Dali::RenderTask *)jarg1;
25440   argp2 = (Dali::Vector2 *)jarg2;
25441   if (!argp2) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25443     return ;
25444   }
25445   arg2 = *argp2;
25446   {
25447     try {
25448       (arg1)->SetViewportPosition(arg2);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25456       };
25457     } catch (...) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25460       };
25461     }
25462   }
25463 }
25464
25465
25466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25467   void * jresult ;
25468   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25469   Dali::Vector2 result;
25470
25471   arg1 = (Dali::RenderTask *)jarg1;
25472   {
25473     try {
25474       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25475     } catch (std::out_of_range& e) {
25476       {
25477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (std::exception& e) {
25480       {
25481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25495   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25496   Dali::Vector2 arg2 ;
25497   Dali::Vector2 *argp2 ;
25498
25499   arg1 = (Dali::RenderTask *)jarg1;
25500   argp2 = (Dali::Vector2 *)jarg2;
25501   if (!argp2) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25503     return ;
25504   }
25505   arg2 = *argp2;
25506   {
25507     try {
25508       (arg1)->SetViewportSize(arg2);
25509     } catch (std::out_of_range& e) {
25510       {
25511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25512       };
25513     } catch (std::exception& e) {
25514       {
25515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25516       };
25517     } catch (...) {
25518       {
25519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25520       };
25521     }
25522   }
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25527   void * jresult ;
25528   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25529   Dali::Vector2 result;
25530
25531   arg1 = (Dali::RenderTask *)jarg1;
25532   {
25533     try {
25534       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (...) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25546       };
25547     }
25548   }
25549   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25550   return jresult;
25551 }
25552
25553
25554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25555   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25556   Dali::Viewport arg2 ;
25557   Dali::Viewport *argp2 ;
25558
25559   arg1 = (Dali::RenderTask *)jarg1;
25560   argp2 = (Dali::Viewport *)jarg2;
25561   if (!argp2) {
25562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25563     return ;
25564   }
25565   arg2 = *argp2;
25566   {
25567     try {
25568       (arg1)->SetViewport(arg2);
25569     } catch (std::out_of_range& e) {
25570       {
25571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25572       };
25573     } catch (std::exception& e) {
25574       {
25575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25580       };
25581     }
25582   }
25583 }
25584
25585
25586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25587   void * jresult ;
25588   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25589   Dali::Viewport result;
25590
25591   arg1 = (Dali::RenderTask *)jarg1;
25592   {
25593     try {
25594       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25595     } catch (std::out_of_range& e) {
25596       {
25597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25598       };
25599     } catch (std::exception& e) {
25600       {
25601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25602       };
25603     } catch (...) {
25604       {
25605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25606       };
25607     }
25608   }
25609   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25610   return jresult;
25611 }
25612
25613
25614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25615   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25616   Dali::Vector4 *arg2 = 0 ;
25617
25618   arg1 = (Dali::RenderTask *)jarg1;
25619   arg2 = (Dali::Vector4 *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25622     return ;
25623   }
25624   {
25625     try {
25626       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25638       };
25639     }
25640   }
25641 }
25642
25643
25644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25645   void * jresult ;
25646   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25647   Dali::Vector4 result;
25648
25649   arg1 = (Dali::RenderTask *)jarg1;
25650   {
25651     try {
25652       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25653     } catch (std::out_of_range& e) {
25654       {
25655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25656       };
25657     } catch (std::exception& e) {
25658       {
25659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25660       };
25661     } catch (...) {
25662       {
25663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25664       };
25665     }
25666   }
25667   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25668   return jresult;
25669 }
25670
25671
25672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25674   bool arg2 ;
25675
25676   arg1 = (Dali::RenderTask *)jarg1;
25677   arg2 = jarg2 ? true : false;
25678   {
25679     try {
25680       (arg1)->SetClearEnabled(arg2);
25681     } catch (std::out_of_range& e) {
25682       {
25683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25684       };
25685     } catch (std::exception& e) {
25686       {
25687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25688       };
25689     } catch (...) {
25690       {
25691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25692       };
25693     }
25694   }
25695 }
25696
25697
25698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25699   unsigned int jresult ;
25700   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25701   bool result;
25702
25703   arg1 = (Dali::RenderTask *)jarg1;
25704   {
25705     try {
25706       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25714       };
25715     } catch (...) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25718       };
25719     }
25720   }
25721   jresult = result;
25722   return jresult;
25723 }
25724
25725
25726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25727   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25728   bool arg2 ;
25729
25730   arg1 = (Dali::RenderTask *)jarg1;
25731   arg2 = jarg2 ? true : false;
25732   {
25733     try {
25734       (arg1)->SetCullMode(arg2);
25735     } catch (std::out_of_range& e) {
25736       {
25737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25738       };
25739     } catch (std::exception& e) {
25740       {
25741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25742       };
25743     } catch (...) {
25744       {
25745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25746       };
25747     }
25748   }
25749 }
25750
25751
25752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25753   unsigned int jresult ;
25754   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25755   bool result;
25756
25757   arg1 = (Dali::RenderTask *)jarg1;
25758   {
25759     try {
25760       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25761     } catch (std::out_of_range& e) {
25762       {
25763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25764       };
25765     } catch (std::exception& e) {
25766       {
25767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25768       };
25769     } catch (...) {
25770       {
25771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25772       };
25773     }
25774   }
25775   jresult = result;
25776   return jresult;
25777 }
25778
25779
25780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25782   unsigned int arg2 ;
25783
25784   arg1 = (Dali::RenderTask *)jarg1;
25785   arg2 = (unsigned int)jarg2;
25786   {
25787     try {
25788       (arg1)->SetRefreshRate(arg2);
25789     } catch (std::out_of_range& e) {
25790       {
25791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25792       };
25793     } catch (std::exception& e) {
25794       {
25795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25796       };
25797     } catch (...) {
25798       {
25799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25800       };
25801     }
25802   }
25803 }
25804
25805
25806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25807   unsigned int jresult ;
25808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25809   unsigned int result;
25810
25811   arg1 = (Dali::RenderTask *)jarg1;
25812   {
25813     try {
25814       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829   jresult = result;
25830   return jresult;
25831 }
25832
25833
25834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25835   unsigned int jresult ;
25836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25837   Dali::Vector3 *arg2 = 0 ;
25838   float *arg3 = 0 ;
25839   float *arg4 = 0 ;
25840   bool result;
25841
25842   arg1 = (Dali::RenderTask *)jarg1;
25843   arg2 = (Dali::Vector3 *)jarg2;
25844   if (!arg2) {
25845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25846     return 0;
25847   }
25848   arg3 = (float *)jarg3;
25849   arg4 = (float *)jarg4;
25850   {
25851     try {
25852       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25853     } catch (std::out_of_range& e) {
25854       {
25855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25856       };
25857     } catch (std::exception& e) {
25858       {
25859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (...) {
25862       {
25863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25864       };
25865     }
25866   }
25867   jresult = result;
25868   return jresult;
25869 }
25870
25871
25872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25873   unsigned int jresult ;
25874   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25875   Dali::Actor arg2 ;
25876   float arg3 ;
25877   float arg4 ;
25878   float *arg5 = 0 ;
25879   float *arg6 = 0 ;
25880   Dali::Actor *argp2 ;
25881   bool result;
25882
25883   arg1 = (Dali::RenderTask *)jarg1;
25884   argp2 = (Dali::Actor *)jarg2;
25885   if (!argp2) {
25886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25887     return 0;
25888   }
25889   arg2 = *argp2;
25890   arg3 = (float)jarg3;
25891   arg4 = (float)jarg4;
25892   arg5 = (float *)jarg5;
25893   arg6 = (float *)jarg6;
25894   {
25895     try {
25896       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(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 = result;
25912   return jresult;
25913 }
25914
25915
25916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25917   void * jresult ;
25918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25919   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25920
25921   arg1 = (Dali::RenderTask *)jarg1;
25922   {
25923     try {
25924       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25925     } catch (std::out_of_range& e) {
25926       {
25927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25928       };
25929     } catch (std::exception& e) {
25930       {
25931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25932       };
25933     } catch (...) {
25934       {
25935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25936       };
25937     }
25938   }
25939   jresult = (void *)result;
25940   return jresult;
25941 }
25942
25943
25944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25945   void * jresult ;
25946   int arg1 ;
25947   Dali::TouchPoint::State arg2 ;
25948   float arg3 ;
25949   float arg4 ;
25950   Dali::TouchPoint *result = 0 ;
25951
25952   arg1 = (int)jarg1;
25953   arg2 = (Dali::TouchPoint::State)jarg2;
25954   arg3 = (float)jarg3;
25955   arg4 = (float)jarg4;
25956   {
25957     try {
25958       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25959     } catch (std::out_of_range& e) {
25960       {
25961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (std::exception& e) {
25964       {
25965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973   jresult = (void *)result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25979   void * jresult ;
25980   int arg1 ;
25981   Dali::TouchPoint::State arg2 ;
25982   float arg3 ;
25983   float arg4 ;
25984   float arg5 ;
25985   float arg6 ;
25986   Dali::TouchPoint *result = 0 ;
25987
25988   arg1 = (int)jarg1;
25989   arg2 = (Dali::TouchPoint::State)jarg2;
25990   arg3 = (float)jarg3;
25991   arg4 = (float)jarg4;
25992   arg5 = (float)jarg5;
25993   arg6 = (float)jarg6;
25994   {
25995     try {
25996       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25997     } catch (std::out_of_range& e) {
25998       {
25999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26000       };
26001     } catch (std::exception& e) {
26002       {
26003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26004       };
26005     } catch (...) {
26006       {
26007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26008       };
26009     }
26010   }
26011   jresult = (void *)result;
26012   return jresult;
26013 }
26014
26015
26016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018
26019   arg1 = (Dali::TouchPoint *)jarg1;
26020   {
26021     try {
26022       delete arg1;
26023     } catch (std::out_of_range& e) {
26024       {
26025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26026       };
26027     } catch (std::exception& e) {
26028       {
26029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26030       };
26031     } catch (...) {
26032       {
26033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26034       };
26035     }
26036   }
26037 }
26038
26039
26040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26041   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26042   int arg2 ;
26043
26044   arg1 = (Dali::TouchPoint *)jarg1;
26045   arg2 = (int)jarg2;
26046   if (arg1) (arg1)->deviceId = arg2;
26047 }
26048
26049
26050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26051   int jresult ;
26052   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26053   int result;
26054
26055   arg1 = (Dali::TouchPoint *)jarg1;
26056   result = (int) ((arg1)->deviceId);
26057   jresult = result;
26058   return jresult;
26059 }
26060
26061
26062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26063   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26064   Dali::TouchPoint::State arg2 ;
26065
26066   arg1 = (Dali::TouchPoint *)jarg1;
26067   arg2 = (Dali::TouchPoint::State)jarg2;
26068   if (arg1) (arg1)->state = arg2;
26069 }
26070
26071
26072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26073   int jresult ;
26074   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26075   Dali::TouchPoint::State result;
26076
26077   arg1 = (Dali::TouchPoint *)jarg1;
26078   result = (Dali::TouchPoint::State) ((arg1)->state);
26079   jresult = (int)result;
26080   return jresult;
26081 }
26082
26083
26084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26085   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26086   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26087
26088   arg1 = (Dali::TouchPoint *)jarg1;
26089   arg2 = (Dali::Actor *)jarg2;
26090   if (arg1) (arg1)->hitActor = *arg2;
26091 }
26092
26093
26094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26095   void * jresult ;
26096   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26097   Dali::Actor *result = 0 ;
26098
26099   arg1 = (Dali::TouchPoint *)jarg1;
26100   result = (Dali::Actor *)& ((arg1)->hitActor);
26101   jresult = (void *)result;
26102   return jresult;
26103 }
26104
26105
26106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26107   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26108   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26109
26110   arg1 = (Dali::TouchPoint *)jarg1;
26111   arg2 = (Dali::Vector2 *)jarg2;
26112   if (arg1) (arg1)->local = *arg2;
26113 }
26114
26115
26116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26117   void * jresult ;
26118   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26119   Dali::Vector2 *result = 0 ;
26120
26121   arg1 = (Dali::TouchPoint *)jarg1;
26122   result = (Dali::Vector2 *)& ((arg1)->local);
26123   jresult = (void *)result;
26124   return jresult;
26125 }
26126
26127
26128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26129   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26130   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26131
26132   arg1 = (Dali::TouchPoint *)jarg1;
26133   arg2 = (Dali::Vector2 *)jarg2;
26134   if (arg1) (arg1)->screen = *arg2;
26135 }
26136
26137
26138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26139   void * jresult ;
26140   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26141   Dali::Vector2 *result = 0 ;
26142
26143   arg1 = (Dali::TouchPoint *)jarg1;
26144   result = (Dali::Vector2 *)& ((arg1)->screen);
26145   jresult = (void *)result;
26146   return jresult;
26147 }
26148
26149
26150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26151   void * jresult ;
26152   Dali::TouchData *result = 0 ;
26153
26154   {
26155     try {
26156       result = (Dali::TouchData *)new Dali::TouchData();
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26164       };
26165     } catch (...) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26168       };
26169     }
26170   }
26171   jresult = (void *)result;
26172   return jresult;
26173 }
26174
26175
26176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26177   void * jresult ;
26178   Dali::TouchData *arg1 = 0 ;
26179   Dali::TouchData *result = 0 ;
26180
26181   arg1 = (Dali::TouchData *)jarg1;
26182   if (!arg1) {
26183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26184     return 0;
26185   }
26186   {
26187     try {
26188       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26189     } catch (std::out_of_range& e) {
26190       {
26191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26192       };
26193     } catch (std::exception& e) {
26194       {
26195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26196       };
26197     } catch (...) {
26198       {
26199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26200       };
26201     }
26202   }
26203   jresult = (void *)result;
26204   return jresult;
26205 }
26206
26207
26208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26209   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26210
26211   arg1 = (Dali::TouchData *)jarg1;
26212   {
26213     try {
26214       delete arg1;
26215     } catch (std::out_of_range& e) {
26216       {
26217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26218       };
26219     } catch (std::exception& e) {
26220       {
26221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26222       };
26223     } catch (...) {
26224       {
26225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26226       };
26227     }
26228   }
26229 }
26230
26231
26232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26233   void * jresult ;
26234   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26235   Dali::TouchData *arg2 = 0 ;
26236   Dali::TouchData *result = 0 ;
26237
26238   arg1 = (Dali::TouchData *)jarg1;
26239   arg2 = (Dali::TouchData *)jarg2;
26240   if (!arg2) {
26241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26242     return 0;
26243   }
26244   {
26245     try {
26246       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26247     } catch (std::out_of_range& e) {
26248       {
26249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26250       };
26251     } catch (std::exception& e) {
26252       {
26253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (...) {
26256       {
26257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26258       };
26259     }
26260   }
26261   jresult = (void *)result;
26262   return jresult;
26263 }
26264
26265
26266 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26267   unsigned long jresult ;
26268   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26269   unsigned long result;
26270
26271   arg1 = (Dali::TouchData *)jarg1;
26272   {
26273     try {
26274       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (...) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26286       };
26287     }
26288   }
26289   jresult = (unsigned long)result;
26290   return jresult;
26291 }
26292
26293
26294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26295   unsigned long jresult ;
26296   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26297   std::size_t result;
26298
26299   arg1 = (Dali::TouchData *)jarg1;
26300   {
26301     try {
26302       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26303     } catch (std::out_of_range& e) {
26304       {
26305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26306       };
26307     } catch (std::exception& e) {
26308       {
26309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26310       };
26311     } catch (...) {
26312       {
26313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26314       };
26315     }
26316   }
26317   jresult = (unsigned long)result;
26318   return jresult;
26319 }
26320
26321
26322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26323   int jresult ;
26324   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26325   std::size_t arg2 ;
26326   int32_t result;
26327
26328   arg1 = (Dali::TouchData *)jarg1;
26329   arg2 = (std::size_t)jarg2;
26330   {
26331     try {
26332       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26333     } catch (std::out_of_range& e) {
26334       {
26335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (std::exception& e) {
26338       {
26339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347   jresult = result;
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26353   int jresult ;
26354   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26355   std::size_t arg2 ;
26356   Dali::PointState::Type result;
26357
26358   arg1 = (Dali::TouchData *)jarg1;
26359   arg2 = (std::size_t)jarg2;
26360   {
26361     try {
26362       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (...) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26374       };
26375     }
26376   }
26377   jresult = (int)result;
26378   return jresult;
26379 }
26380
26381
26382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26383   void * jresult ;
26384   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26385   std::size_t arg2 ;
26386   Dali::Actor result;
26387
26388   arg1 = (Dali::TouchData *)jarg1;
26389   arg2 = (std::size_t)jarg2;
26390   {
26391     try {
26392       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26400       };
26401     } catch (...) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26404       };
26405     }
26406   }
26407   jresult = new Dali::Actor((const Dali::Actor &)result);
26408   return jresult;
26409 }
26410
26411
26412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26413   void * jresult ;
26414   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26415   std::size_t arg2 ;
26416   Dali::Vector2 *result = 0 ;
26417
26418   arg1 = (Dali::TouchData *)jarg1;
26419   arg2 = (std::size_t)jarg2;
26420   {
26421     try {
26422       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26423     } catch (std::out_of_range& e) {
26424       {
26425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26426       };
26427     } catch (std::exception& e) {
26428       {
26429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26430       };
26431     } catch (...) {
26432       {
26433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26434       };
26435     }
26436   }
26437   jresult = (void *)result;
26438   return jresult;
26439 }
26440
26441
26442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26443   void * jresult ;
26444   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26445   std::size_t arg2 ;
26446   Dali::Vector2 *result = 0 ;
26447
26448   arg1 = (Dali::TouchData *)jarg1;
26449   arg2 = (std::size_t)jarg2;
26450   {
26451     try {
26452       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26453     } catch (std::out_of_range& e) {
26454       {
26455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26456       };
26457     } catch (std::exception& e) {
26458       {
26459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26460       };
26461     } catch (...) {
26462       {
26463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26464       };
26465     }
26466   }
26467   jresult = (void *)result;
26468   return jresult;
26469 }
26470
26471
26472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26473   float jresult ;
26474   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26475   std::size_t arg2 ;
26476   float result;
26477
26478   arg1 = (Dali::TouchData *)jarg1;
26479   arg2 = (std::size_t)jarg2;
26480   {
26481     try {
26482       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26483     } catch (std::out_of_range& e) {
26484       {
26485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26486       };
26487     } catch (std::exception& e) {
26488       {
26489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26490       };
26491     } catch (...) {
26492       {
26493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26494       };
26495     }
26496   }
26497   jresult = result;
26498   return jresult;
26499 }
26500
26501
26502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26503   void * jresult ;
26504   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26505   std::size_t arg2 ;
26506   Dali::Vector2 *result = 0 ;
26507
26508   arg1 = (Dali::TouchData *)jarg1;
26509   arg2 = (std::size_t)jarg2;
26510   {
26511     try {
26512       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26513     } catch (std::out_of_range& e) {
26514       {
26515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26516       };
26517     } catch (std::exception& e) {
26518       {
26519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26520       };
26521     } catch (...) {
26522       {
26523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26524       };
26525     }
26526   }
26527   jresult = (void *)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26533   float jresult ;
26534   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26535   std::size_t arg2 ;
26536   float result;
26537
26538   arg1 = (Dali::TouchData *)jarg1;
26539   arg2 = (std::size_t)jarg2;
26540   {
26541     try {
26542       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26543     } catch (std::out_of_range& e) {
26544       {
26545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26546       };
26547     } catch (std::exception& e) {
26548       {
26549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26550       };
26551     } catch (...) {
26552       {
26553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26554       };
26555     }
26556   }
26557   jresult = result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26563   void * jresult ;
26564   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26565   std::size_t arg2 ;
26566   Dali::Degree result;
26567
26568   arg1 = (Dali::TouchData *)jarg1;
26569   arg2 = (std::size_t)jarg2;
26570   {
26571     try {
26572       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26573     } catch (std::out_of_range& e) {
26574       {
26575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26576       };
26577     } catch (std::exception& e) {
26578       {
26579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (...) {
26582       {
26583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26584       };
26585     }
26586   }
26587   jresult = new Dali::Degree((const Dali::Degree &)result);
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26593   void * jresult ;
26594   Dali::GestureDetector *result = 0 ;
26595
26596   {
26597     try {
26598       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26599     } catch (std::out_of_range& e) {
26600       {
26601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26602       };
26603     } catch (std::exception& e) {
26604       {
26605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26606       };
26607     } catch (...) {
26608       {
26609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26610       };
26611     }
26612   }
26613   jresult = (void *)result;
26614   return jresult;
26615 }
26616
26617
26618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26619   void * jresult ;
26620   Dali::BaseHandle arg1 ;
26621   Dali::BaseHandle *argp1 ;
26622   Dali::GestureDetector result;
26623
26624   argp1 = (Dali::BaseHandle *)jarg1;
26625   if (!argp1) {
26626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26627     return 0;
26628   }
26629   arg1 = *argp1;
26630   {
26631     try {
26632       result = Dali::GestureDetector::DownCast(arg1);
26633     } catch (std::out_of_range& e) {
26634       {
26635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26636       };
26637     } catch (std::exception& e) {
26638       {
26639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26640       };
26641     } catch (...) {
26642       {
26643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26644       };
26645     }
26646   }
26647   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26653   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26654
26655   arg1 = (Dali::GestureDetector *)jarg1;
26656   {
26657     try {
26658       delete arg1;
26659     } catch (std::out_of_range& e) {
26660       {
26661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26662       };
26663     } catch (std::exception& e) {
26664       {
26665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26666       };
26667     } catch (...) {
26668       {
26669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26670       };
26671     }
26672   }
26673 }
26674
26675
26676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26677   void * jresult ;
26678   Dali::GestureDetector *arg1 = 0 ;
26679   Dali::GestureDetector *result = 0 ;
26680
26681   arg1 = (Dali::GestureDetector *)jarg1;
26682   if (!arg1) {
26683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26684     return 0;
26685   }
26686   {
26687     try {
26688       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26689     } catch (std::out_of_range& e) {
26690       {
26691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26692       };
26693     } catch (std::exception& e) {
26694       {
26695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26696       };
26697     } catch (...) {
26698       {
26699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26700       };
26701     }
26702   }
26703   jresult = (void *)result;
26704   return jresult;
26705 }
26706
26707
26708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26709   void * jresult ;
26710   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26711   Dali::GestureDetector *arg2 = 0 ;
26712   Dali::GestureDetector *result = 0 ;
26713
26714   arg1 = (Dali::GestureDetector *)jarg1;
26715   arg2 = (Dali::GestureDetector *)jarg2;
26716   if (!arg2) {
26717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26718     return 0;
26719   }
26720   {
26721     try {
26722       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26723     } catch (std::out_of_range& e) {
26724       {
26725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26726       };
26727     } catch (std::exception& e) {
26728       {
26729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26730       };
26731     } catch (...) {
26732       {
26733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26734       };
26735     }
26736   }
26737   jresult = (void *)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26743   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26744   Dali::Actor arg2 ;
26745   Dali::Actor *argp2 ;
26746
26747   arg1 = (Dali::GestureDetector *)jarg1;
26748   argp2 = (Dali::Actor *)jarg2;
26749   if (!argp2) {
26750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26751     return ;
26752   }
26753   arg2 = *argp2;
26754   {
26755     try {
26756       (arg1)->Attach(arg2);
26757     } catch (std::out_of_range& e) {
26758       {
26759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26760       };
26761     } catch (std::exception& e) {
26762       {
26763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26764       };
26765     } catch (...) {
26766       {
26767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26768       };
26769     }
26770   }
26771 }
26772
26773
26774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26775   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26776   Dali::Actor arg2 ;
26777   Dali::Actor *argp2 ;
26778
26779   arg1 = (Dali::GestureDetector *)jarg1;
26780   argp2 = (Dali::Actor *)jarg2;
26781   if (!argp2) {
26782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26783     return ;
26784   }
26785   arg2 = *argp2;
26786   {
26787     try {
26788       (arg1)->Detach(arg2);
26789     } catch (std::out_of_range& e) {
26790       {
26791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26792       };
26793     } catch (std::exception& e) {
26794       {
26795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (...) {
26798       {
26799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26800       };
26801     }
26802   }
26803 }
26804
26805
26806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26807   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26808
26809   arg1 = (Dali::GestureDetector *)jarg1;
26810   {
26811     try {
26812       (arg1)->DetachAll();
26813     } catch (std::out_of_range& e) {
26814       {
26815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (std::exception& e) {
26818       {
26819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827 }
26828
26829
26830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26831   unsigned long jresult ;
26832   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26833   size_t result;
26834
26835   arg1 = (Dali::GestureDetector *)jarg1;
26836   {
26837     try {
26838       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26839     } catch (std::out_of_range& e) {
26840       {
26841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26842       };
26843     } catch (std::exception& e) {
26844       {
26845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26846       };
26847     } catch (...) {
26848       {
26849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26850       };
26851     }
26852   }
26853   jresult = (unsigned long)result;
26854   return jresult;
26855 }
26856
26857
26858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26859   void * jresult ;
26860   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26861   size_t arg2 ;
26862   Dali::Actor result;
26863
26864   arg1 = (Dali::GestureDetector *)jarg1;
26865   arg2 = (size_t)jarg2;
26866   {
26867     try {
26868       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26869     } catch (std::out_of_range& e) {
26870       {
26871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26872       };
26873     } catch (std::exception& e) {
26874       {
26875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26876       };
26877     } catch (...) {
26878       {
26879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26880       };
26881     }
26882   }
26883   jresult = new Dali::Actor((const Dali::Actor &)result);
26884   return jresult;
26885 }
26886
26887
26888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26889   void * jresult ;
26890   Dali::Gesture *arg1 = 0 ;
26891   Dali::Gesture *result = 0 ;
26892
26893   arg1 = (Dali::Gesture *)jarg1;
26894   if (!arg1) {
26895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26896     return 0;
26897   }
26898   {
26899     try {
26900       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26901     } catch (std::out_of_range& e) {
26902       {
26903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (std::exception& e) {
26906       {
26907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26908       };
26909     } catch (...) {
26910       {
26911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26912       };
26913     }
26914   }
26915   jresult = (void *)result;
26916   return jresult;
26917 }
26918
26919
26920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26921   void * jresult ;
26922   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26923   Dali::Gesture *arg2 = 0 ;
26924   Dali::Gesture *result = 0 ;
26925
26926   arg1 = (Dali::Gesture *)jarg1;
26927   arg2 = (Dali::Gesture *)jarg2;
26928   if (!arg2) {
26929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26930     return 0;
26931   }
26932   {
26933     try {
26934       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26935     } catch (std::out_of_range& e) {
26936       {
26937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26938       };
26939     } catch (std::exception& e) {
26940       {
26941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26942       };
26943     } catch (...) {
26944       {
26945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26946       };
26947     }
26948   }
26949   jresult = (void *)result;
26950   return jresult;
26951 }
26952
26953
26954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26955   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26956
26957   arg1 = (Dali::Gesture *)jarg1;
26958   {
26959     try {
26960       delete arg1;
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (...) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26972       };
26973     }
26974   }
26975 }
26976
26977
26978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26979   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26980   Dali::Gesture::Type arg2 ;
26981
26982   arg1 = (Dali::Gesture *)jarg1;
26983   arg2 = (Dali::Gesture::Type)jarg2;
26984   if (arg1) (arg1)->type = arg2;
26985 }
26986
26987
26988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26989   int jresult ;
26990   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26991   Dali::Gesture::Type result;
26992
26993   arg1 = (Dali::Gesture *)jarg1;
26994   result = (Dali::Gesture::Type) ((arg1)->type);
26995   jresult = (int)result;
26996   return jresult;
26997 }
26998
26999
27000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
27001   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27002   Dali::Gesture::State arg2 ;
27003
27004   arg1 = (Dali::Gesture *)jarg1;
27005   arg2 = (Dali::Gesture::State)jarg2;
27006   if (arg1) (arg1)->state = arg2;
27007 }
27008
27009
27010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27011   int jresult ;
27012   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27013   Dali::Gesture::State result;
27014
27015   arg1 = (Dali::Gesture *)jarg1;
27016   result = (Dali::Gesture::State) ((arg1)->state);
27017   jresult = (int)result;
27018   return jresult;
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27023   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27024   unsigned int arg2 ;
27025
27026   arg1 = (Dali::Gesture *)jarg1;
27027   arg2 = (unsigned int)jarg2;
27028   if (arg1) (arg1)->time = arg2;
27029 }
27030
27031
27032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27033   unsigned int jresult ;
27034   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27035   unsigned int result;
27036
27037   arg1 = (Dali::Gesture *)jarg1;
27038   result = (unsigned int) ((arg1)->time);
27039   jresult = result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27045   void * jresult ;
27046   Dali::HoverEvent *result = 0 ;
27047
27048   {
27049     try {
27050       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27051     } catch (std::out_of_range& e) {
27052       {
27053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27054       };
27055     } catch (std::exception& e) {
27056       {
27057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27058       };
27059     } catch (...) {
27060       {
27061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27062       };
27063     }
27064   }
27065   jresult = (void *)result;
27066   return jresult;
27067 }
27068
27069
27070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27071   void * jresult ;
27072   unsigned long arg1 ;
27073   Dali::HoverEvent *result = 0 ;
27074
27075   arg1 = (unsigned long)jarg1;
27076   {
27077     try {
27078       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27079     } catch (std::out_of_range& e) {
27080       {
27081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27082       };
27083     } catch (std::exception& e) {
27084       {
27085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27086       };
27087     } catch (...) {
27088       {
27089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27090       };
27091     }
27092   }
27093   jresult = (void *)result;
27094   return jresult;
27095 }
27096
27097
27098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27099   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27100
27101   arg1 = (Dali::HoverEvent *)jarg1;
27102   {
27103     try {
27104       delete arg1;
27105     } catch (std::out_of_range& e) {
27106       {
27107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27108       };
27109     } catch (std::exception& e) {
27110       {
27111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27112       };
27113     } catch (...) {
27114       {
27115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27116       };
27117     }
27118   }
27119 }
27120
27121
27122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27123   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27124   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27125
27126   arg1 = (Dali::HoverEvent *)jarg1;
27127   arg2 = (Dali::TouchPointContainer *)jarg2;
27128   if (arg1) (arg1)->points = *arg2;
27129 }
27130
27131
27132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27133   void * jresult ;
27134   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27135   Dali::TouchPointContainer *result = 0 ;
27136
27137   arg1 = (Dali::HoverEvent *)jarg1;
27138   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27139   jresult = (void *)result;
27140   return jresult;
27141 }
27142
27143
27144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27145   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27146   unsigned long arg2 ;
27147
27148   arg1 = (Dali::HoverEvent *)jarg1;
27149   arg2 = (unsigned long)jarg2;
27150   if (arg1) (arg1)->time = arg2;
27151 }
27152
27153
27154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27155   unsigned long jresult ;
27156   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27157   unsigned long result;
27158
27159   arg1 = (Dali::HoverEvent *)jarg1;
27160   result = (unsigned long) ((arg1)->time);
27161   jresult = (unsigned long)result;
27162   return jresult;
27163 }
27164
27165
27166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27167   unsigned int jresult ;
27168   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27169   unsigned int result;
27170
27171   arg1 = (Dali::HoverEvent *)jarg1;
27172   {
27173     try {
27174       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27175     } catch (std::out_of_range& e) {
27176       {
27177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27178       };
27179     } catch (std::exception& e) {
27180       {
27181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27182       };
27183     } catch (...) {
27184       {
27185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27186       };
27187     }
27188   }
27189   jresult = result;
27190   return jresult;
27191 }
27192
27193
27194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27195   void * jresult ;
27196   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27197   unsigned int arg2 ;
27198   Dali::TouchPoint *result = 0 ;
27199
27200   arg1 = (Dali::HoverEvent *)jarg1;
27201   arg2 = (unsigned int)jarg2;
27202   {
27203     try {
27204       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27205     } catch (std::out_of_range& e) {
27206       {
27207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27208       };
27209     } catch (std::exception& e) {
27210       {
27211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27212       };
27213     } catch (...) {
27214       {
27215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27216       };
27217     }
27218   }
27219   jresult = (void *)result;
27220   return jresult;
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27225   void * jresult ;
27226   Dali::KeyEvent *result = 0 ;
27227
27228   {
27229     try {
27230       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27242       };
27243     }
27244   }
27245   jresult = (void *)result;
27246   return jresult;
27247 }
27248
27249
27250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27251   void * jresult ;
27252   std::string *arg1 = 0 ;
27253   std::string *arg2 = 0 ;
27254   int arg3 ;
27255   int arg4 ;
27256   unsigned long arg5 ;
27257   Dali::KeyEvent::State *arg6 = 0 ;
27258   Dali::KeyEvent::State temp6 ;
27259   Dali::KeyEvent *result = 0 ;
27260
27261   if (!jarg1) {
27262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27263     return 0;
27264   }
27265   std::string arg1_str(jarg1);
27266   arg1 = &arg1_str;
27267   if (!jarg2) {
27268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27269     return 0;
27270   }
27271   std::string arg2_str(jarg2);
27272   arg2 = &arg2_str;
27273   arg3 = (int)jarg3;
27274   arg4 = (int)jarg4;
27275   arg5 = (unsigned long)jarg5;
27276   temp6 = (Dali::KeyEvent::State)jarg6;
27277   arg6 = &temp6;
27278   {
27279     try {
27280       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27281     } catch (std::out_of_range& e) {
27282       {
27283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27284       };
27285     } catch (std::exception& e) {
27286       {
27287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27288       };
27289     } catch (...) {
27290       {
27291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27292       };
27293     }
27294   }
27295   jresult = (void *)result;
27296
27297   //argout typemap for const std::string&
27298
27299
27300   //argout typemap for const std::string&
27301
27302   return jresult;
27303 }
27304
27305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27306   void * jresult ;
27307   Dali::KeyEvent *arg1 = 0 ;
27308   Dali::KeyEvent *result = 0 ;
27309
27310   arg1 = (Dali::KeyEvent *)jarg1;
27311   if (!arg1) {
27312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27313     return 0;
27314   }
27315   {
27316     try {
27317       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27318     } catch (std::out_of_range& e) {
27319       {
27320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27321       };
27322     } catch (std::exception& e) {
27323       {
27324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27325       };
27326     } catch (...) {
27327       {
27328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27329       };
27330     }
27331   }
27332   jresult = (void *)result;
27333   return jresult;
27334 }
27335
27336
27337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27338   void * jresult ;
27339   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27340   Dali::KeyEvent *arg2 = 0 ;
27341   Dali::KeyEvent *result = 0 ;
27342
27343   arg1 = (Dali::KeyEvent *)jarg1;
27344   arg2 = (Dali::KeyEvent *)jarg2;
27345   if (!arg2) {
27346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27347     return 0;
27348   }
27349   {
27350     try {
27351       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27352     } catch (std::out_of_range& e) {
27353       {
27354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (std::exception& e) {
27357       {
27358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (...) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27363       };
27364     }
27365   }
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27372   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27373
27374   arg1 = (Dali::KeyEvent *)jarg1;
27375   {
27376     try {
27377       delete arg1;
27378     } catch (std::out_of_range& e) {
27379       {
27380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27381       };
27382     } catch (std::exception& e) {
27383       {
27384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27385       };
27386     } catch (...) {
27387       {
27388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27389       };
27390     }
27391   }
27392 }
27393
27394
27395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27396   unsigned int jresult ;
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   bool result;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   {
27402     try {
27403       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27411       };
27412     } catch (...) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27415       };
27416     }
27417   }
27418   jresult = result;
27419   return jresult;
27420 }
27421
27422
27423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27424   unsigned int jresult ;
27425   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27426   bool result;
27427
27428   arg1 = (Dali::KeyEvent *)jarg1;
27429   {
27430     try {
27431       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27432     } catch (std::out_of_range& e) {
27433       {
27434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27435       };
27436     } catch (std::exception& e) {
27437       {
27438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27439       };
27440     } catch (...) {
27441       {
27442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27443       };
27444     }
27445   }
27446   jresult = result;
27447   return jresult;
27448 }
27449
27450
27451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27452   unsigned int jresult ;
27453   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27454   bool result;
27455
27456   arg1 = (Dali::KeyEvent *)jarg1;
27457   {
27458     try {
27459       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27460     } catch (std::out_of_range& e) {
27461       {
27462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (std::exception& e) {
27465       {
27466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474   jresult = result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27480   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27481   std::string *arg2 = 0 ;
27482
27483   arg1 = (Dali::KeyEvent *)jarg1;
27484   if (!jarg2) {
27485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27486     return ;
27487   }
27488   std::string arg2_str(jarg2);
27489   arg2 = &arg2_str;
27490   if (arg1) (arg1)->keyPressedName = *arg2;
27491
27492   //argout typemap for const std::string&
27493
27494 }
27495
27496
27497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27498   char * jresult ;
27499   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27500   std::string *result = 0 ;
27501
27502   arg1 = (Dali::KeyEvent *)jarg1;
27503   result = (std::string *) & ((arg1)->keyPressedName);
27504   jresult = SWIG_csharp_string_callback(result->c_str());
27505   return jresult;
27506 }
27507
27508
27509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27510   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27511   std::string *arg2 = 0 ;
27512
27513   arg1 = (Dali::KeyEvent *)jarg1;
27514   if (!jarg2) {
27515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27516     return ;
27517   }
27518   std::string arg2_str(jarg2);
27519   arg2 = &arg2_str;
27520   if (arg1) (arg1)->keyPressed = *arg2;
27521
27522   //argout typemap for const std::string&
27523
27524 }
27525
27526
27527 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27528   char * jresult ;
27529   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27530   std::string *result = 0 ;
27531
27532   arg1 = (Dali::KeyEvent *)jarg1;
27533   result = (std::string *) & ((arg1)->keyPressed);
27534   jresult = SWIG_csharp_string_callback(result->c_str());
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27540   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27541   int arg2 ;
27542
27543   arg1 = (Dali::KeyEvent *)jarg1;
27544   arg2 = (int)jarg2;
27545   if (arg1) (arg1)->keyCode = arg2;
27546 }
27547
27548
27549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27550   int jresult ;
27551   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27552   int result;
27553
27554   arg1 = (Dali::KeyEvent *)jarg1;
27555   result = (int) ((arg1)->keyCode);
27556   jresult = result;
27557   return jresult;
27558 }
27559
27560
27561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27562   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27563   int arg2 ;
27564
27565   arg1 = (Dali::KeyEvent *)jarg1;
27566   arg2 = (int)jarg2;
27567   if (arg1) (arg1)->keyModifier = arg2;
27568 }
27569
27570
27571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27572   int jresult ;
27573   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27574   int result;
27575
27576   arg1 = (Dali::KeyEvent *)jarg1;
27577   result = (int) ((arg1)->keyModifier);
27578   jresult = result;
27579   return jresult;
27580 }
27581
27582
27583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27584   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27585   unsigned long arg2 ;
27586
27587   arg1 = (Dali::KeyEvent *)jarg1;
27588   arg2 = (unsigned long)jarg2;
27589   if (arg1) (arg1)->time = arg2;
27590 }
27591
27592
27593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27594   unsigned long jresult ;
27595   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27596   unsigned long result;
27597
27598   arg1 = (Dali::KeyEvent *)jarg1;
27599   result = (unsigned long) ((arg1)->time);
27600   jresult = (unsigned long)result;
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27606   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27607   Dali::KeyEvent::State arg2 ;
27608
27609   arg1 = (Dali::KeyEvent *)jarg1;
27610   arg2 = (Dali::KeyEvent::State)jarg2;
27611   if (arg1) (arg1)->state = arg2;
27612 }
27613
27614
27615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27616   int jresult ;
27617   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27618   Dali::KeyEvent::State result;
27619
27620   arg1 = (Dali::KeyEvent *)jarg1;
27621   result = (Dali::KeyEvent::State) ((arg1)->state);
27622   jresult = (int)result;
27623   return jresult;
27624 }
27625
27626
27627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27628   void * jresult ;
27629   Dali::LongPressGestureDetector *result = 0 ;
27630
27631   {
27632     try {
27633       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27634     } catch (std::out_of_range& e) {
27635       {
27636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27637       };
27638     } catch (std::exception& e) {
27639       {
27640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27645       };
27646     }
27647   }
27648   jresult = (void *)result;
27649   return jresult;
27650 }
27651
27652
27653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27654   void * jresult ;
27655   Dali::LongPressGestureDetector result;
27656
27657   {
27658     try {
27659       result = Dali::LongPressGestureDetector::New();
27660     } catch (std::out_of_range& e) {
27661       {
27662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27663       };
27664     } catch (std::exception& e) {
27665       {
27666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27667       };
27668     } catch (...) {
27669       {
27670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27671       };
27672     }
27673   }
27674   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27675   return jresult;
27676 }
27677
27678
27679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27680   void * jresult ;
27681   unsigned int arg1 ;
27682   Dali::LongPressGestureDetector result;
27683
27684   arg1 = (unsigned int)jarg1;
27685   {
27686     try {
27687       result = Dali::LongPressGestureDetector::New(arg1);
27688     } catch (std::out_of_range& e) {
27689       {
27690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27691       };
27692     } catch (std::exception& e) {
27693       {
27694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27695       };
27696     } catch (...) {
27697       {
27698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27699       };
27700     }
27701   }
27702   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27703   return jresult;
27704 }
27705
27706
27707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27708   void * jresult ;
27709   unsigned int arg1 ;
27710   unsigned int arg2 ;
27711   Dali::LongPressGestureDetector result;
27712
27713   arg1 = (unsigned int)jarg1;
27714   arg2 = (unsigned int)jarg2;
27715   {
27716     try {
27717       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27725       };
27726     } catch (...) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27729       };
27730     }
27731   }
27732   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27733   return jresult;
27734 }
27735
27736
27737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27738   void * jresult ;
27739   Dali::BaseHandle arg1 ;
27740   Dali::BaseHandle *argp1 ;
27741   Dali::LongPressGestureDetector result;
27742
27743   argp1 = (Dali::BaseHandle *)jarg1;
27744   if (!argp1) {
27745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27746     return 0;
27747   }
27748   arg1 = *argp1;
27749   {
27750     try {
27751       result = Dali::LongPressGestureDetector::DownCast(arg1);
27752     } catch (std::out_of_range& e) {
27753       {
27754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27755       };
27756     } catch (std::exception& e) {
27757       {
27758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (...) {
27761       {
27762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27763       };
27764     }
27765   }
27766   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27767   return jresult;
27768 }
27769
27770
27771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27772   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27773
27774   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27775   {
27776     try {
27777       delete arg1;
27778     } catch (std::out_of_range& e) {
27779       {
27780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27781       };
27782     } catch (std::exception& e) {
27783       {
27784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27785       };
27786     } catch (...) {
27787       {
27788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27789       };
27790     }
27791   }
27792 }
27793
27794
27795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27796   void * jresult ;
27797   Dali::LongPressGestureDetector *arg1 = 0 ;
27798   Dali::LongPressGestureDetector *result = 0 ;
27799
27800   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27801   if (!arg1) {
27802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27803     return 0;
27804   }
27805   {
27806     try {
27807       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27808     } catch (std::out_of_range& e) {
27809       {
27810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27811       };
27812     } catch (std::exception& e) {
27813       {
27814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27815       };
27816     } catch (...) {
27817       {
27818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27819       };
27820     }
27821   }
27822   jresult = (void *)result;
27823   return jresult;
27824 }
27825
27826
27827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27828   void * jresult ;
27829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27830   Dali::LongPressGestureDetector *arg2 = 0 ;
27831   Dali::LongPressGestureDetector *result = 0 ;
27832
27833   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27834   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27835   if (!arg2) {
27836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27837     return 0;
27838   }
27839   {
27840     try {
27841       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27849       };
27850     } catch (...) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27853       };
27854     }
27855   }
27856   jresult = (void *)result;
27857   return jresult;
27858 }
27859
27860
27861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27863   unsigned int arg2 ;
27864
27865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27866   arg2 = (unsigned int)jarg2;
27867   {
27868     try {
27869       (arg1)->SetTouchesRequired(arg2);
27870     } catch (std::out_of_range& e) {
27871       {
27872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27873       };
27874     } catch (std::exception& e) {
27875       {
27876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27877       };
27878     } catch (...) {
27879       {
27880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27881       };
27882     }
27883   }
27884 }
27885
27886
27887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27888   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27889   unsigned int arg2 ;
27890   unsigned int arg3 ;
27891
27892   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27893   arg2 = (unsigned int)jarg2;
27894   arg3 = (unsigned int)jarg3;
27895   {
27896     try {
27897       (arg1)->SetTouchesRequired(arg2,arg3);
27898     } catch (std::out_of_range& e) {
27899       {
27900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27901       };
27902     } catch (std::exception& e) {
27903       {
27904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27905       };
27906     } catch (...) {
27907       {
27908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27909       };
27910     }
27911   }
27912 }
27913
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27916   unsigned int jresult ;
27917   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27918   unsigned int result;
27919
27920   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27921   {
27922     try {
27923       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (...) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27935       };
27936     }
27937   }
27938   jresult = result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27944   unsigned int jresult ;
27945   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27946   unsigned int result;
27947
27948   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27949   {
27950     try {
27951       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27952     } catch (std::out_of_range& e) {
27953       {
27954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27955       };
27956     } catch (std::exception& e) {
27957       {
27958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (...) {
27961       {
27962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27963       };
27964     }
27965   }
27966   jresult = result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27972   void * jresult ;
27973   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27974   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27975
27976   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27977   {
27978     try {
27979       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27980     } catch (std::out_of_range& e) {
27981       {
27982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (std::exception& e) {
27985       {
27986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994   jresult = (void *)result;
27995   return jresult;
27996 }
27997
27998
27999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
28000   void * jresult ;
28001   Dali::Gesture::State arg1 ;
28002   Dali::LongPressGesture *result = 0 ;
28003
28004   arg1 = (Dali::Gesture::State)jarg1;
28005   {
28006     try {
28007       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28008     } catch (std::out_of_range& e) {
28009       {
28010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28011       };
28012     } catch (std::exception& e) {
28013       {
28014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28015       };
28016     } catch (...) {
28017       {
28018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28019       };
28020     }
28021   }
28022   jresult = (void *)result;
28023   return jresult;
28024 }
28025
28026
28027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28028   void * jresult ;
28029   Dali::LongPressGesture *arg1 = 0 ;
28030   Dali::LongPressGesture *result = 0 ;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   if (!arg1) {
28034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28035     return 0;
28036   }
28037   {
28038     try {
28039       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28040     } catch (std::out_of_range& e) {
28041       {
28042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28043       };
28044     } catch (std::exception& e) {
28045       {
28046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28047       };
28048     } catch (...) {
28049       {
28050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28051       };
28052     }
28053   }
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28060   void * jresult ;
28061   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28062   Dali::LongPressGesture *arg2 = 0 ;
28063   Dali::LongPressGesture *result = 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (Dali::LongPressGesture *)jarg2;
28067   if (!arg2) {
28068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28069     return 0;
28070   }
28071   {
28072     try {
28073       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28074     } catch (std::out_of_range& e) {
28075       {
28076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28077       };
28078     } catch (std::exception& e) {
28079       {
28080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28081       };
28082     } catch (...) {
28083       {
28084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28085       };
28086     }
28087   }
28088   jresult = (void *)result;
28089   return jresult;
28090 }
28091
28092
28093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28094   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28095
28096   arg1 = (Dali::LongPressGesture *)jarg1;
28097   {
28098     try {
28099       delete arg1;
28100     } catch (std::out_of_range& e) {
28101       {
28102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28103       };
28104     } catch (std::exception& e) {
28105       {
28106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28107       };
28108     } catch (...) {
28109       {
28110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28111       };
28112     }
28113   }
28114 }
28115
28116
28117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28118   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28119   unsigned int arg2 ;
28120
28121   arg1 = (Dali::LongPressGesture *)jarg1;
28122   arg2 = (unsigned int)jarg2;
28123   if (arg1) (arg1)->numberOfTouches = arg2;
28124 }
28125
28126
28127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28128   unsigned int jresult ;
28129   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28130   unsigned int result;
28131
28132   arg1 = (Dali::LongPressGesture *)jarg1;
28133   result = (unsigned int) ((arg1)->numberOfTouches);
28134   jresult = result;
28135   return jresult;
28136 }
28137
28138
28139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28140   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28141   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28142
28143   arg1 = (Dali::LongPressGesture *)jarg1;
28144   arg2 = (Dali::Vector2 *)jarg2;
28145   if (arg1) (arg1)->screenPoint = *arg2;
28146 }
28147
28148
28149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28150   void * jresult ;
28151   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28152   Dali::Vector2 *result = 0 ;
28153
28154   arg1 = (Dali::LongPressGesture *)jarg1;
28155   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28156   jresult = (void *)result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28162   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28164
28165   arg1 = (Dali::LongPressGesture *)jarg1;
28166   arg2 = (Dali::Vector2 *)jarg2;
28167   if (arg1) (arg1)->localPoint = *arg2;
28168 }
28169
28170
28171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28172   void * jresult ;
28173   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28174   Dali::Vector2 *result = 0 ;
28175
28176   arg1 = (Dali::LongPressGesture *)jarg1;
28177   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28178   jresult = (void *)result;
28179   return jresult;
28180 }
28181
28182
28183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28184   void * jresult ;
28185   Dali::WheelEvent *result = 0 ;
28186
28187   {
28188     try {
28189       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28190     } catch (std::out_of_range& e) {
28191       {
28192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28193       };
28194     } catch (std::exception& e) {
28195       {
28196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28197       };
28198     } catch (...) {
28199       {
28200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28201       };
28202     }
28203   }
28204   jresult = (void *)result;
28205   return jresult;
28206 }
28207
28208
28209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28210   void * jresult ;
28211   Dali::WheelEvent::Type arg1 ;
28212   int arg2 ;
28213   unsigned int arg3 ;
28214   Dali::Vector2 arg4 ;
28215   int arg5 ;
28216   unsigned int arg6 ;
28217   Dali::Vector2 *argp4 ;
28218   Dali::WheelEvent *result = 0 ;
28219
28220   arg1 = (Dali::WheelEvent::Type)jarg1;
28221   arg2 = (int)jarg2;
28222   arg3 = (unsigned int)jarg3;
28223   argp4 = (Dali::Vector2 *)jarg4;
28224   if (!argp4) {
28225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28226     return 0;
28227   }
28228   arg4 = *argp4;
28229   arg5 = (int)jarg5;
28230   arg6 = (unsigned int)jarg6;
28231   {
28232     try {
28233       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28234     } catch (std::out_of_range& e) {
28235       {
28236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (std::exception& e) {
28239       {
28240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28241       };
28242     } catch (...) {
28243       {
28244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28245       };
28246     }
28247   }
28248   jresult = (void *)result;
28249   return jresult;
28250 }
28251
28252
28253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28254   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28255
28256   arg1 = (Dali::WheelEvent *)jarg1;
28257   {
28258     try {
28259       delete arg1;
28260     } catch (std::out_of_range& e) {
28261       {
28262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28263       };
28264     } catch (std::exception& e) {
28265       {
28266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28267       };
28268     } catch (...) {
28269       {
28270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28271       };
28272     }
28273   }
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28278   unsigned int jresult ;
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   bool result;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   {
28284     try {
28285       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28286     } catch (std::out_of_range& e) {
28287       {
28288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28289       };
28290     } catch (std::exception& e) {
28291       {
28292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28293       };
28294     } catch (...) {
28295       {
28296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28297       };
28298     }
28299   }
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28306   unsigned int jresult ;
28307   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28308   bool result;
28309
28310   arg1 = (Dali::WheelEvent *)jarg1;
28311   {
28312     try {
28313       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28314     } catch (std::out_of_range& e) {
28315       {
28316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (std::exception& e) {
28319       {
28320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28325       };
28326     }
28327   }
28328   jresult = result;
28329   return jresult;
28330 }
28331
28332
28333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28334   unsigned int jresult ;
28335   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28336   bool result;
28337
28338   arg1 = (Dali::WheelEvent *)jarg1;
28339   {
28340     try {
28341       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28342     } catch (std::out_of_range& e) {
28343       {
28344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28345       };
28346     } catch (std::exception& e) {
28347       {
28348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28349       };
28350     } catch (...) {
28351       {
28352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28353       };
28354     }
28355   }
28356   jresult = result;
28357   return jresult;
28358 }
28359
28360
28361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28362   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28363   Dali::WheelEvent::Type arg2 ;
28364
28365   arg1 = (Dali::WheelEvent *)jarg1;
28366   arg2 = (Dali::WheelEvent::Type)jarg2;
28367   if (arg1) (arg1)->type = arg2;
28368 }
28369
28370
28371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28372   int jresult ;
28373   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28374   Dali::WheelEvent::Type result;
28375
28376   arg1 = (Dali::WheelEvent *)jarg1;
28377   result = (Dali::WheelEvent::Type) ((arg1)->type);
28378   jresult = (int)result;
28379   return jresult;
28380 }
28381
28382
28383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28384   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28385   int arg2 ;
28386
28387   arg1 = (Dali::WheelEvent *)jarg1;
28388   arg2 = (int)jarg2;
28389   if (arg1) (arg1)->direction = arg2;
28390 }
28391
28392
28393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28394   int jresult ;
28395   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28396   int result;
28397
28398   arg1 = (Dali::WheelEvent *)jarg1;
28399   result = (int) ((arg1)->direction);
28400   jresult = result;
28401   return jresult;
28402 }
28403
28404
28405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28406   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28407   unsigned int arg2 ;
28408
28409   arg1 = (Dali::WheelEvent *)jarg1;
28410   arg2 = (unsigned int)jarg2;
28411   if (arg1) (arg1)->modifiers = arg2;
28412 }
28413
28414
28415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28416   unsigned int jresult ;
28417   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28418   unsigned int result;
28419
28420   arg1 = (Dali::WheelEvent *)jarg1;
28421   result = (unsigned int) ((arg1)->modifiers);
28422   jresult = result;
28423   return jresult;
28424 }
28425
28426
28427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28428   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28429   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28430
28431   arg1 = (Dali::WheelEvent *)jarg1;
28432   arg2 = (Dali::Vector2 *)jarg2;
28433   if (arg1) (arg1)->point = *arg2;
28434 }
28435
28436
28437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28438   void * jresult ;
28439   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28440   Dali::Vector2 *result = 0 ;
28441
28442   arg1 = (Dali::WheelEvent *)jarg1;
28443   result = (Dali::Vector2 *)& ((arg1)->point);
28444   jresult = (void *)result;
28445   return jresult;
28446 }
28447
28448
28449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28450   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28451   int arg2 ;
28452
28453   arg1 = (Dali::WheelEvent *)jarg1;
28454   arg2 = (int)jarg2;
28455   if (arg1) (arg1)->z = arg2;
28456 }
28457
28458
28459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28460   int jresult ;
28461   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28462   int result;
28463
28464   arg1 = (Dali::WheelEvent *)jarg1;
28465   result = (int) ((arg1)->z);
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28472   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28473   unsigned int arg2 ;
28474
28475   arg1 = (Dali::WheelEvent *)jarg1;
28476   arg2 = (unsigned int)jarg2;
28477   if (arg1) (arg1)->timeStamp = arg2;
28478 }
28479
28480
28481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28482   unsigned int jresult ;
28483   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28484   unsigned int result;
28485
28486   arg1 = (Dali::WheelEvent *)jarg1;
28487   result = (unsigned int) ((arg1)->timeStamp);
28488   jresult = result;
28489   return jresult;
28490 }
28491
28492 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28493   char * jresult ;
28494   Dali::KeyEvent *arg1 = 0 ;
28495   std::string result;
28496
28497   arg1 = (Dali::KeyEvent *)jarg1;
28498   if (!arg1) {
28499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28500     return 0;
28501   }
28502   {
28503     try {
28504       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28505     } catch (std::out_of_range& e) {
28506       {
28507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28508       };
28509     } catch (std::exception& e) {
28510       {
28511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28512       };
28513     } catch (...) {
28514       {
28515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28516       };
28517     }
28518   }
28519   jresult = SWIG_csharp_string_callback((&result)->c_str());
28520   return jresult;
28521 }
28522
28523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28524   int jresult ;
28525   Dali::KeyEvent *arg1 = 0 ;
28526   Dali::DevelKeyEvent::DeviceClass::Type result;
28527
28528   arg1 = (Dali::KeyEvent *)jarg1;
28529   if (!arg1) {
28530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28531     return 0;
28532   }
28533   {
28534     try {
28535       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28536     } catch (std::out_of_range& e) {
28537       {
28538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28539       };
28540     } catch (std::exception& e) {
28541       {
28542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28543       };
28544     } catch (...) {
28545       {
28546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28547       };
28548     }
28549   }
28550   jresult = (int)result;
28551   return jresult;
28552 }
28553
28554
28555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28556   Dali::Actor arg1 ;
28557   Dali::Actor *argp1 ;
28558
28559   argp1 = (Dali::Actor *)jarg1;
28560   if (!argp1) {
28561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28562     return ;
28563   }
28564   arg1 = *argp1;
28565   {
28566     try {
28567       Dali::DevelActor::Raise(arg1);
28568     } catch (std::out_of_range& e) {
28569       {
28570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28571       };
28572     } catch (std::exception& e) {
28573       {
28574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28579       };
28580     }
28581   }
28582 }
28583
28584
28585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28586   Dali::Actor arg1 ;
28587   Dali::Actor *argp1 ;
28588
28589   argp1 = (Dali::Actor *)jarg1;
28590   if (!argp1) {
28591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28592     return ;
28593   }
28594   arg1 = *argp1;
28595   {
28596     try {
28597       Dali::DevelActor::Lower(arg1);
28598     } catch (std::out_of_range& e) {
28599       {
28600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28601       };
28602     } catch (std::exception& e) {
28603       {
28604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28605       };
28606     } catch (...) {
28607       {
28608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28609       };
28610     }
28611   }
28612 }
28613
28614
28615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28616   Dali::Actor arg1 ;
28617   Dali::Actor *argp1 ;
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   {
28626     try {
28627       Dali::DevelActor::RaiseToTop(arg1);
28628     } catch (std::out_of_range& e) {
28629       {
28630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28631       };
28632     } catch (std::exception& e) {
28633       {
28634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28635       };
28636     } catch (...) {
28637       {
28638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28639       };
28640     }
28641   }
28642 }
28643
28644
28645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28646   Dali::Actor arg1 ;
28647   Dali::Actor *argp1 ;
28648
28649   argp1 = (Dali::Actor *)jarg1;
28650   if (!argp1) {
28651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28652     return ;
28653   }
28654   arg1 = *argp1;
28655   {
28656     try {
28657       Dali::DevelActor::LowerToBottom(arg1);
28658     } catch (std::out_of_range& e) {
28659       {
28660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28661       };
28662     } catch (std::exception& e) {
28663       {
28664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28669       };
28670     }
28671   }
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28676   Dali::Actor arg1 ;
28677   Dali::Actor arg2 ;
28678   Dali::Actor *argp1 ;
28679   Dali::Actor *argp2 ;
28680
28681   argp1 = (Dali::Actor *)jarg1;
28682   if (!argp1) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28684     return ;
28685   }
28686   arg1 = *argp1;
28687   argp2 = (Dali::Actor *)jarg2;
28688   if (!argp2) {
28689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28690     return ;
28691   }
28692   arg2 = *argp2;
28693   {
28694     try {
28695       Dali::DevelActor::RaiseAbove(arg1,arg2);
28696     } catch (std::out_of_range& e) {
28697       {
28698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28699       };
28700     } catch (std::exception& e) {
28701       {
28702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28703       };
28704     } catch (...) {
28705       {
28706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28707       };
28708     }
28709   }
28710 }
28711
28712
28713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28714   Dali::Actor arg1 ;
28715   Dali::Actor arg2 ;
28716   Dali::Actor *argp1 ;
28717   Dali::Actor *argp2 ;
28718
28719   argp1 = (Dali::Actor *)jarg1;
28720   if (!argp1) {
28721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28722     return ;
28723   }
28724   arg1 = *argp1;
28725   argp2 = (Dali::Actor *)jarg2;
28726   if (!argp2) {
28727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28728     return ;
28729   }
28730   arg2 = *argp2;
28731   {
28732     try {
28733       Dali::DevelActor::LowerBelow(arg1,arg2);
28734     } catch (std::out_of_range& e) {
28735       {
28736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28737       };
28738     } catch (std::exception& e) {
28739       {
28740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28741       };
28742     } catch (...) {
28743       {
28744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28745       };
28746     }
28747   }
28748 }
28749
28750
28751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28752   void * jresult ;
28753   Dali::Actor arg1 ;
28754   Dali::Actor *argp1 ;
28755   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28756
28757   argp1 = (Dali::Actor *)jarg1;
28758   if (!argp1) {
28759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28760     return 0;
28761   }
28762   arg1 = *argp1;
28763   {
28764     try {
28765       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28766     } catch (std::out_of_range& e) {
28767       {
28768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28769       };
28770     } catch (std::exception& e) {
28771       {
28772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28773       };
28774     } catch (...) {
28775       {
28776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28777       };
28778     }
28779   }
28780   jresult = (void *)result;
28781   return jresult;
28782 }
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::SIZE;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::POSITION;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::POSITION_X;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::POSITION_Y;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::POSITION_Z;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::WORLD_POSITION;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::ORIENTATION;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::SCALE;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::SCALE_X;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::SCALE_Y;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::SCALE_Z;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::WORLD_SCALE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::VISIBLE;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::COLOR;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29075   int jresult ;
29076   int result;
29077
29078   result = (int)Dali::Actor::Property::COLOR_RED;
29079   jresult = (int)result;
29080   return jresult;
29081 }
29082
29083
29084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29085   int jresult ;
29086   int result;
29087
29088   result = (int)Dali::Actor::Property::COLOR_GREEN;
29089   jresult = (int)result;
29090   return jresult;
29091 }
29092
29093
29094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29095   int jresult ;
29096   int result;
29097
29098   result = (int)Dali::Actor::Property::COLOR_BLUE;
29099   jresult = (int)result;
29100   return jresult;
29101 }
29102
29103
29104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29105   int jresult ;
29106   int result;
29107
29108   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29109   jresult = (int)result;
29110   return jresult;
29111 }
29112
29113
29114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29115   int jresult ;
29116   int result;
29117
29118   result = (int)Dali::Actor::Property::WORLD_COLOR;
29119   jresult = (int)result;
29120   return jresult;
29121 }
29122
29123
29124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29125   int jresult ;
29126   int result;
29127
29128   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29129   jresult = (int)result;
29130   return jresult;
29131 }
29132
29133
29134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29135   int jresult ;
29136   int result;
29137
29138   result = (int)Dali::Actor::Property::NAME;
29139   jresult = (int)result;
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29145   int jresult ;
29146   int result;
29147
29148   result = (int)Dali::Actor::Property::SENSITIVE;
29149   jresult = (int)result;
29150   return jresult;
29151 }
29152
29153
29154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29155   int jresult ;
29156   int result;
29157
29158   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29159   jresult = (int)result;
29160   return jresult;
29161 }
29162
29163
29164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29165   int jresult ;
29166   int result;
29167
29168   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29169   jresult = (int)result;
29170   return jresult;
29171 }
29172
29173
29174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29175   int jresult ;
29176   int result;
29177
29178   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29179   jresult = (int)result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29185   int jresult ;
29186   int result;
29187
29188   result = (int)Dali::Actor::Property::COLOR_MODE;
29189   jresult = (int)result;
29190   return jresult;
29191 }
29192
29193
29194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29195   int jresult ;
29196   int result;
29197
29198   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29199   jresult = (int)result;
29200   return jresult;
29201 }
29202
29203
29204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29205   int jresult ;
29206   int result;
29207
29208   result = (int)Dali::Actor::Property::DRAW_MODE;
29209   jresult = (int)result;
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29215   int jresult ;
29216   int result;
29217
29218   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29219   jresult = (int)result;
29220   return jresult;
29221 }
29222
29223
29224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29225   int jresult ;
29226   int result;
29227
29228   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29229   jresult = (int)result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29235   int jresult ;
29236   int result;
29237
29238   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29239   jresult = (int)result;
29240   return jresult;
29241 }
29242
29243
29244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29245   int jresult ;
29246   int result;
29247
29248   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29249   jresult = (int)result;
29250   return jresult;
29251 }
29252
29253
29254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29255   int jresult ;
29256   int result;
29257
29258   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29259   jresult = (int)result;
29260   return jresult;
29261 }
29262
29263
29264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29265   int jresult ;
29266   int result;
29267
29268   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29269   jresult = (int)result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29275   int jresult ;
29276   int result;
29277
29278   result = (int)Dali::Actor::Property::PADDING;
29279   jresult = (int)result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29285   int jresult ;
29286   int result;
29287
29288   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29289   jresult = (int)result;
29290   return jresult;
29291 }
29292
29293
29294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29295   int jresult ;
29296   int result;
29297
29298   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29299   jresult = (int)result;
29300   return jresult;
29301 }
29302
29303
29304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29305   int jresult ;
29306   int result;
29307
29308   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29309   jresult = (int)result;
29310   return jresult;
29311 }
29312
29313
29314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29315   int jresult ;
29316   int result;
29317
29318   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29319   jresult = (int)result;
29320   return jresult;
29321 }
29322
29323
29324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29325   void * jresult ;
29326   Dali::Actor::Property *result = 0 ;
29327
29328   {
29329     try {
29330       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29331     } catch (std::out_of_range& e) {
29332       {
29333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29334       };
29335     } catch (std::exception& e) {
29336       {
29337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29338       };
29339     } catch (...) {
29340       {
29341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29342       };
29343     }
29344   }
29345   jresult = (void *)result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29351   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29352
29353   arg1 = (Dali::Actor::Property *)jarg1;
29354   {
29355     try {
29356       delete arg1;
29357     } catch (std::out_of_range& e) {
29358       {
29359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (std::exception& e) {
29362       {
29363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371 }
29372
29373
29374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29375   void * jresult ;
29376   Dali::Actor *result = 0 ;
29377
29378   {
29379     try {
29380       result = (Dali::Actor *)new Dali::Actor();
29381     } catch (std::out_of_range& e) {
29382       {
29383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29384       };
29385     } catch (std::exception& e) {
29386       {
29387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29388       };
29389     } catch (...) {
29390       {
29391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29392       };
29393     }
29394   }
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29401   void * jresult ;
29402   Dali::Actor result;
29403
29404   {
29405     try {
29406       result = Dali::Actor::New();
29407     } catch (std::out_of_range& e) {
29408       {
29409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29410       };
29411     } catch (std::exception& e) {
29412       {
29413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29414       };
29415     } catch (...) {
29416       {
29417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29418       };
29419     }
29420   }
29421   jresult = new Dali::Actor((const Dali::Actor &)result);
29422   return jresult;
29423 }
29424
29425
29426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29427   void * jresult ;
29428   Dali::BaseHandle arg1 ;
29429   Dali::BaseHandle *argp1 ;
29430   Dali::Actor result;
29431
29432   argp1 = (Dali::BaseHandle *)jarg1;
29433   if (!argp1) {
29434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29435     return 0;
29436   }
29437   arg1 = *argp1;
29438   {
29439     try {
29440       result = Dali::Actor::DownCast(arg1);
29441     } catch (std::out_of_range& e) {
29442       {
29443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29444       };
29445     } catch (std::exception& e) {
29446       {
29447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (...) {
29450       {
29451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29452       };
29453     }
29454   }
29455   jresult = new Dali::Actor((const Dali::Actor &)result);
29456   return jresult;
29457 }
29458
29459
29460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29462
29463   arg1 = (Dali::Actor *)jarg1;
29464   {
29465     try {
29466       delete arg1;
29467     } catch (std::out_of_range& e) {
29468       {
29469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29470       };
29471     } catch (std::exception& e) {
29472       {
29473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29474       };
29475     } catch (...) {
29476       {
29477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29478       };
29479     }
29480   }
29481 }
29482
29483
29484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29485   void * jresult ;
29486   Dali::Actor *arg1 = 0 ;
29487   Dali::Actor *result = 0 ;
29488
29489   arg1 = (Dali::Actor *)jarg1;
29490   if (!arg1) {
29491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29492     return 0;
29493   }
29494   {
29495     try {
29496       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29508       };
29509     }
29510   }
29511   jresult = (void *)result;
29512   return jresult;
29513 }
29514
29515
29516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29517   void * jresult ;
29518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29519   Dali::Actor *arg2 = 0 ;
29520   Dali::Actor *result = 0 ;
29521
29522   arg1 = (Dali::Actor *)jarg1;
29523   arg2 = (Dali::Actor *)jarg2;
29524   if (!arg2) {
29525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29526     return 0;
29527   }
29528   {
29529     try {
29530       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (...) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29542       };
29543     }
29544   }
29545   jresult = (void *)result;
29546   return jresult;
29547 }
29548
29549
29550 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29551   char * jresult ;
29552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29553   std::string *result = 0 ;
29554
29555   arg1 = (Dali::Actor *)jarg1;
29556   {
29557     try {
29558       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29559     } catch (std::out_of_range& e) {
29560       {
29561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29562       };
29563     } catch (std::exception& e) {
29564       {
29565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29566       };
29567     } catch (...) {
29568       {
29569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29570       };
29571     }
29572   }
29573   jresult = SWIG_csharp_string_callback(result->c_str());
29574   return jresult;
29575 }
29576
29577
29578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29580   std::string *arg2 = 0 ;
29581
29582   arg1 = (Dali::Actor *)jarg1;
29583   if (!jarg2) {
29584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29585     return ;
29586   }
29587   std::string arg2_str(jarg2);
29588   arg2 = &arg2_str;
29589   {
29590     try {
29591       (arg1)->SetName((std::string const &)*arg2);
29592     } catch (std::out_of_range& e) {
29593       {
29594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29595       };
29596     } catch (std::exception& e) {
29597       {
29598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29599       };
29600     } catch (...) {
29601       {
29602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29603       };
29604     }
29605   }
29606
29607   //argout typemap for const std::string&
29608
29609 }
29610
29611
29612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29613   unsigned int jresult ;
29614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29615   unsigned int result;
29616
29617   arg1 = (Dali::Actor *)jarg1;
29618   {
29619     try {
29620       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29621     } catch (std::out_of_range& e) {
29622       {
29623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29624       };
29625     } catch (std::exception& e) {
29626       {
29627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29628       };
29629     } catch (...) {
29630       {
29631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29632       };
29633     }
29634   }
29635   jresult = result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29641   unsigned int jresult ;
29642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29643   bool result;
29644
29645   arg1 = (Dali::Actor *)jarg1;
29646   {
29647     try {
29648       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29649     } catch (std::out_of_range& e) {
29650       {
29651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29652       };
29653     } catch (std::exception& e) {
29654       {
29655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (...) {
29658       {
29659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29660       };
29661     }
29662   }
29663   jresult = result;
29664   return jresult;
29665 }
29666
29667
29668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29669   unsigned int jresult ;
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   bool result;
29672
29673   arg1 = (Dali::Actor *)jarg1;
29674   {
29675     try {
29676       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29677     } catch (std::out_of_range& e) {
29678       {
29679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29680       };
29681     } catch (std::exception& e) {
29682       {
29683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29684       };
29685     } catch (...) {
29686       {
29687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29688       };
29689     }
29690   }
29691   jresult = result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29697   unsigned int jresult ;
29698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29699   bool result;
29700
29701   arg1 = (Dali::Actor *)jarg1;
29702   {
29703     try {
29704       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29705     } catch (std::out_of_range& e) {
29706       {
29707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (std::exception& e) {
29710       {
29711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719   jresult = result;
29720   return jresult;
29721 }
29722
29723
29724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29725   void * jresult ;
29726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29727   Dali::Layer result;
29728
29729   arg1 = (Dali::Actor *)jarg1;
29730   {
29731     try {
29732       result = (arg1)->GetLayer();
29733     } catch (std::out_of_range& e) {
29734       {
29735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29736       };
29737     } catch (std::exception& e) {
29738       {
29739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29740       };
29741     } catch (...) {
29742       {
29743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29744       };
29745     }
29746   }
29747   jresult = new Dali::Layer((const Dali::Layer &)result);
29748   return jresult;
29749 }
29750
29751
29752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29754   Dali::Actor arg2 ;
29755   Dali::Actor *argp2 ;
29756
29757   arg1 = (Dali::Actor *)jarg1;
29758   argp2 = (Dali::Actor *)jarg2;
29759   if (!argp2) {
29760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29761     return ;
29762   }
29763   arg2 = *argp2;
29764   {
29765     try {
29766       (arg1)->Add(arg2);
29767     } catch (std::out_of_range& e) {
29768       {
29769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29770       };
29771     } catch (std::exception& e) {
29772       {
29773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29774       };
29775     } catch (...) {
29776       {
29777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29778       };
29779     }
29780   }
29781 }
29782
29783
29784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29786   Dali::Actor arg2 ;
29787   Dali::Actor *argp2 ;
29788
29789   arg1 = (Dali::Actor *)jarg1;
29790   argp2 = (Dali::Actor *)jarg2;
29791   if (!argp2) {
29792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29793     return ;
29794   }
29795   arg2 = *argp2;
29796   {
29797     try {
29798       (arg1)->Remove(arg2);
29799     } catch (std::out_of_range& e) {
29800       {
29801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29802       };
29803     } catch (std::exception& e) {
29804       {
29805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29806       };
29807     } catch (...) {
29808       {
29809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29810       };
29811     }
29812   }
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29818
29819   arg1 = (Dali::Actor *)jarg1;
29820   {
29821     try {
29822       (arg1)->Unparent();
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (...) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29834       };
29835     }
29836   }
29837 }
29838
29839
29840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29841   unsigned int jresult ;
29842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29843   unsigned int result;
29844
29845   arg1 = (Dali::Actor *)jarg1;
29846   {
29847     try {
29848       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29849     } catch (std::out_of_range& e) {
29850       {
29851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (std::exception& e) {
29854       {
29855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29856       };
29857     } catch (...) {
29858       {
29859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29860       };
29861     }
29862   }
29863   jresult = result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29869   void * jresult ;
29870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29871   unsigned int arg2 ;
29872   Dali::Actor result;
29873
29874   arg1 = (Dali::Actor *)jarg1;
29875   arg2 = (unsigned int)jarg2;
29876   {
29877     try {
29878       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29879     } catch (std::out_of_range& e) {
29880       {
29881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29882       };
29883     } catch (std::exception& e) {
29884       {
29885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29886       };
29887     } catch (...) {
29888       {
29889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29890       };
29891     }
29892   }
29893   jresult = new Dali::Actor((const Dali::Actor &)result);
29894   return jresult;
29895 }
29896
29897
29898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29899   void * jresult ;
29900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29901   std::string *arg2 = 0 ;
29902   Dali::Actor result;
29903
29904   arg1 = (Dali::Actor *)jarg1;
29905   if (!jarg2) {
29906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29907     return 0;
29908   }
29909   std::string arg2_str(jarg2);
29910   arg2 = &arg2_str;
29911   {
29912     try {
29913       result = (arg1)->FindChildByName((std::string const &)*arg2);
29914     } catch (std::out_of_range& e) {
29915       {
29916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29917       };
29918     } catch (std::exception& e) {
29919       {
29920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (...) {
29923       {
29924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29925       };
29926     }
29927   }
29928   jresult = new Dali::Actor((const Dali::Actor &)result);
29929
29930   //argout typemap for const std::string&
29931
29932   return jresult;
29933 }
29934
29935
29936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29937   void * jresult ;
29938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29939   unsigned int arg2 ;
29940   Dali::Actor result;
29941
29942   arg1 = (Dali::Actor *)jarg1;
29943   arg2 = (unsigned int)jarg2;
29944   {
29945     try {
29946       result = (arg1)->FindChildById(arg2);
29947     } catch (std::out_of_range& e) {
29948       {
29949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (std::exception& e) {
29952       {
29953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961   jresult = new Dali::Actor((const Dali::Actor &)result);
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29967   void * jresult ;
29968   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29969   Dali::Actor result;
29970
29971   arg1 = (Dali::Actor *)jarg1;
29972   {
29973     try {
29974       result = ((Dali::Actor const *)arg1)->GetParent();
29975     } catch (std::out_of_range& e) {
29976       {
29977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29978       };
29979     } catch (std::exception& e) {
29980       {
29981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (...) {
29984       {
29985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29986       };
29987     }
29988   }
29989   jresult = new Dali::Actor((const Dali::Actor &)result);
29990   return jresult;
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29996   Dali::Vector3 *arg2 = 0 ;
29997
29998   arg1 = (Dali::Actor *)jarg1;
29999   arg2 = (Dali::Vector3 *)jarg2;
30000   if (!arg2) {
30001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30002     return ;
30003   }
30004   {
30005     try {
30006       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30007     } catch (std::out_of_range& e) {
30008       {
30009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30010       };
30011     } catch (std::exception& e) {
30012       {
30013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30014       };
30015     } catch (...) {
30016       {
30017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30018       };
30019     }
30020   }
30021 }
30022
30023
30024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30025   void * jresult ;
30026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30027   Dali::Vector3 result;
30028
30029   arg1 = (Dali::Actor *)jarg1;
30030   {
30031     try {
30032       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (...) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30044       };
30045     }
30046   }
30047   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30048   return jresult;
30049 }
30050
30051
30052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30054   Dali::Vector3 *arg2 = 0 ;
30055
30056   arg1 = (Dali::Actor *)jarg1;
30057   arg2 = (Dali::Vector3 *)jarg2;
30058   if (!arg2) {
30059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30060     return ;
30061   }
30062   {
30063     try {
30064       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30065     } catch (std::out_of_range& e) {
30066       {
30067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30068       };
30069     } catch (std::exception& e) {
30070       {
30071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30072       };
30073     } catch (...) {
30074       {
30075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30076       };
30077     }
30078   }
30079 }
30080
30081
30082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30083   void * jresult ;
30084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30085   Dali::Vector3 result;
30086
30087   arg1 = (Dali::Actor *)jarg1;
30088   {
30089     try {
30090       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30091     } catch (std::out_of_range& e) {
30092       {
30093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30094       };
30095     } catch (std::exception& e) {
30096       {
30097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30102       };
30103     }
30104   }
30105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30112   float arg2 ;
30113   float arg3 ;
30114
30115   arg1 = (Dali::Actor *)jarg1;
30116   arg2 = (float)jarg2;
30117   arg3 = (float)jarg3;
30118   {
30119     try {
30120       (arg1)->SetSize(arg2,arg3);
30121     } catch (std::out_of_range& e) {
30122       {
30123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30124       };
30125     } catch (std::exception& e) {
30126       {
30127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30132       };
30133     }
30134   }
30135 }
30136
30137
30138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30140   float arg2 ;
30141   float arg3 ;
30142   float arg4 ;
30143
30144   arg1 = (Dali::Actor *)jarg1;
30145   arg2 = (float)jarg2;
30146   arg3 = (float)jarg3;
30147   arg4 = (float)jarg4;
30148   {
30149     try {
30150       (arg1)->SetSize(arg2,arg3,arg4);
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30158       };
30159     } catch (...) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30162       };
30163     }
30164   }
30165 }
30166
30167
30168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30170   Dali::Vector2 *arg2 = 0 ;
30171
30172   arg1 = (Dali::Actor *)jarg1;
30173   arg2 = (Dali::Vector2 *)jarg2;
30174   if (!arg2) {
30175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30176     return ;
30177   }
30178   {
30179     try {
30180       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30181     } catch (std::out_of_range& e) {
30182       {
30183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30184       };
30185     } catch (std::exception& e) {
30186       {
30187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30192       };
30193     }
30194   }
30195 }
30196
30197
30198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30200   Dali::Vector3 *arg2 = 0 ;
30201
30202   arg1 = (Dali::Actor *)jarg1;
30203   arg2 = (Dali::Vector3 *)jarg2;
30204   if (!arg2) {
30205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30206     return ;
30207   }
30208   {
30209     try {
30210       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30211     } catch (std::out_of_range& e) {
30212       {
30213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30214       };
30215     } catch (std::exception& e) {
30216       {
30217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30218       };
30219     } catch (...) {
30220       {
30221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30222       };
30223     }
30224   }
30225 }
30226
30227
30228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30229   void * jresult ;
30230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30231   Dali::Vector3 result;
30232
30233   arg1 = (Dali::Actor *)jarg1;
30234   {
30235     try {
30236       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30237     } catch (std::out_of_range& e) {
30238       {
30239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30240       };
30241     } catch (std::exception& e) {
30242       {
30243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (...) {
30246       {
30247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30248       };
30249     }
30250   }
30251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30252   return jresult;
30253 }
30254
30255
30256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30257   void * jresult ;
30258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30259   Dali::Vector3 result;
30260
30261   arg1 = (Dali::Actor *)jarg1;
30262   {
30263     try {
30264       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30265     } catch (std::out_of_range& e) {
30266       {
30267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30268       };
30269     } catch (std::exception& e) {
30270       {
30271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30276       };
30277     }
30278   }
30279   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30280   return jresult;
30281 }
30282
30283
30284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30285   void * jresult ;
30286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30287   Dali::Vector3 result;
30288
30289   arg1 = (Dali::Actor *)jarg1;
30290   {
30291     try {
30292       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30304       };
30305     }
30306   }
30307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30308   return jresult;
30309 }
30310
30311
30312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30314   float arg2 ;
30315   float arg3 ;
30316
30317   arg1 = (Dali::Actor *)jarg1;
30318   arg2 = (float)jarg2;
30319   arg3 = (float)jarg3;
30320   {
30321     try {
30322       (arg1)->SetPosition(arg2,arg3);
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30334       };
30335     }
30336   }
30337 }
30338
30339
30340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30342   float arg2 ;
30343   float arg3 ;
30344   float arg4 ;
30345
30346   arg1 = (Dali::Actor *)jarg1;
30347   arg2 = (float)jarg2;
30348   arg3 = (float)jarg3;
30349   arg4 = (float)jarg4;
30350   {
30351     try {
30352       (arg1)->SetPosition(arg2,arg3,arg4);
30353     } catch (std::out_of_range& e) {
30354       {
30355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30356       };
30357     } catch (std::exception& e) {
30358       {
30359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30360       };
30361     } catch (...) {
30362       {
30363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30364       };
30365     }
30366   }
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30372   Dali::Vector3 *arg2 = 0 ;
30373
30374   arg1 = (Dali::Actor *)jarg1;
30375   arg2 = (Dali::Vector3 *)jarg2;
30376   if (!arg2) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30378     return ;
30379   }
30380   {
30381     try {
30382       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30383     } catch (std::out_of_range& e) {
30384       {
30385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30386       };
30387     } catch (std::exception& e) {
30388       {
30389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30390       };
30391     } catch (...) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30394       };
30395     }
30396   }
30397 }
30398
30399
30400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30401   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30402   float arg2 ;
30403
30404   arg1 = (Dali::Actor *)jarg1;
30405   arg2 = (float)jarg2;
30406   {
30407     try {
30408       (arg1)->SetX(arg2);
30409     } catch (std::out_of_range& e) {
30410       {
30411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30412       };
30413     } catch (std::exception& e) {
30414       {
30415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30420       };
30421     }
30422   }
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   float arg2 ;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   arg2 = (float)jarg2;
30432   {
30433     try {
30434       (arg1)->SetY(arg2);
30435     } catch (std::out_of_range& e) {
30436       {
30437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30438       };
30439     } catch (std::exception& e) {
30440       {
30441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (...) {
30444       {
30445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30446       };
30447     }
30448   }
30449 }
30450
30451
30452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30454   float arg2 ;
30455
30456   arg1 = (Dali::Actor *)jarg1;
30457   arg2 = (float)jarg2;
30458   {
30459     try {
30460       (arg1)->SetZ(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (...) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30472       };
30473     }
30474   }
30475 }
30476
30477
30478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30480   Dali::Vector3 *arg2 = 0 ;
30481
30482   arg1 = (Dali::Actor *)jarg1;
30483   arg2 = (Dali::Vector3 *)jarg2;
30484   if (!arg2) {
30485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30486     return ;
30487   }
30488   {
30489     try {
30490       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30491     } catch (std::out_of_range& e) {
30492       {
30493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30494       };
30495     } catch (std::exception& e) {
30496       {
30497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30498       };
30499     } catch (...) {
30500       {
30501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30502       };
30503     }
30504   }
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30509   void * jresult ;
30510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30511   Dali::Vector3 result;
30512
30513   arg1 = (Dali::Actor *)jarg1;
30514   {
30515     try {
30516       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30517     } catch (std::out_of_range& e) {
30518       {
30519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30520       };
30521     } catch (std::exception& e) {
30522       {
30523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30524       };
30525     } catch (...) {
30526       {
30527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30528       };
30529     }
30530   }
30531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30532   return jresult;
30533 }
30534
30535
30536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30537   void * jresult ;
30538   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30539   Dali::Vector3 result;
30540
30541   arg1 = (Dali::Actor *)jarg1;
30542   {
30543     try {
30544       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30545     } catch (std::out_of_range& e) {
30546       {
30547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30548       };
30549     } catch (std::exception& e) {
30550       {
30551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30552       };
30553     } catch (...) {
30554       {
30555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30556       };
30557     }
30558   }
30559   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30560   return jresult;
30561 }
30562
30563
30564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30566   bool arg2 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = jarg2 ? true : false;
30570   {
30571     try {
30572       (arg1)->SetInheritPosition(arg2);
30573     } catch (std::out_of_range& e) {
30574       {
30575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30576       };
30577     } catch (std::exception& e) {
30578       {
30579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30584       };
30585     }
30586   }
30587 }
30588
30589
30590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30591   int jresult ;
30592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30593   Dali::PositionInheritanceMode result;
30594
30595   arg1 = (Dali::Actor *)jarg1;
30596   {
30597     try {
30598       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30610       };
30611     }
30612   }
30613   jresult = (int)result;
30614   return jresult;
30615 }
30616
30617
30618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30619   unsigned int jresult ;
30620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30621   bool result;
30622
30623   arg1 = (Dali::Actor *)jarg1;
30624   {
30625     try {
30626       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30627     } catch (std::out_of_range& e) {
30628       {
30629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30630       };
30631     } catch (std::exception& e) {
30632       {
30633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30634       };
30635     } catch (...) {
30636       {
30637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30638       };
30639     }
30640   }
30641   jresult = result;
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30648   Dali::Degree *arg2 = 0 ;
30649   Dali::Vector3 *arg3 = 0 ;
30650
30651   arg1 = (Dali::Actor *)jarg1;
30652   arg2 = (Dali::Degree *)jarg2;
30653   if (!arg2) {
30654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30655     return ;
30656   }
30657   arg3 = (Dali::Vector3 *)jarg3;
30658   if (!arg3) {
30659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30660     return ;
30661   }
30662   {
30663     try {
30664       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30665     } catch (std::out_of_range& e) {
30666       {
30667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30668       };
30669     } catch (std::exception& e) {
30670       {
30671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30676       };
30677     }
30678   }
30679 }
30680
30681
30682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30684   Dali::Radian *arg2 = 0 ;
30685   Dali::Vector3 *arg3 = 0 ;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   arg2 = (Dali::Radian *)jarg2;
30689   if (!arg2) {
30690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30691     return ;
30692   }
30693   arg3 = (Dali::Vector3 *)jarg3;
30694   if (!arg3) {
30695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30696     return ;
30697   }
30698   {
30699     try {
30700       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30701     } catch (std::out_of_range& e) {
30702       {
30703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30704       };
30705     } catch (std::exception& e) {
30706       {
30707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30712       };
30713     }
30714   }
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30720   Dali::Quaternion *arg2 = 0 ;
30721
30722   arg1 = (Dali::Actor *)jarg1;
30723   arg2 = (Dali::Quaternion *)jarg2;
30724   if (!arg2) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30726     return ;
30727   }
30728   {
30729     try {
30730       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745 }
30746
30747
30748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30750   Dali::Degree *arg2 = 0 ;
30751   Dali::Vector3 *arg3 = 0 ;
30752
30753   arg1 = (Dali::Actor *)jarg1;
30754   arg2 = (Dali::Degree *)jarg2;
30755   if (!arg2) {
30756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30757     return ;
30758   }
30759   arg3 = (Dali::Vector3 *)jarg3;
30760   if (!arg3) {
30761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30762     return ;
30763   }
30764   {
30765     try {
30766       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30767     } catch (std::out_of_range& e) {
30768       {
30769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30770       };
30771     } catch (std::exception& e) {
30772       {
30773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30774       };
30775     } catch (...) {
30776       {
30777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30778       };
30779     }
30780   }
30781 }
30782
30783
30784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30786   Dali::Radian *arg2 = 0 ;
30787   Dali::Vector3 *arg3 = 0 ;
30788
30789   arg1 = (Dali::Actor *)jarg1;
30790   arg2 = (Dali::Radian *)jarg2;
30791   if (!arg2) {
30792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30793     return ;
30794   }
30795   arg3 = (Dali::Vector3 *)jarg3;
30796   if (!arg3) {
30797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30798     return ;
30799   }
30800   {
30801     try {
30802       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30814       };
30815     }
30816   }
30817 }
30818
30819
30820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30822   Dali::Quaternion *arg2 = 0 ;
30823
30824   arg1 = (Dali::Actor *)jarg1;
30825   arg2 = (Dali::Quaternion *)jarg2;
30826   if (!arg2) {
30827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30828     return ;
30829   }
30830   {
30831     try {
30832       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30833     } catch (std::out_of_range& e) {
30834       {
30835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (std::exception& e) {
30838       {
30839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30840       };
30841     } catch (...) {
30842       {
30843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30844       };
30845     }
30846   }
30847 }
30848
30849
30850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30851   void * jresult ;
30852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30853   Dali::Quaternion result;
30854
30855   arg1 = (Dali::Actor *)jarg1;
30856   {
30857     try {
30858       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30859     } catch (std::out_of_range& e) {
30860       {
30861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (std::exception& e) {
30864       {
30865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30866       };
30867     } catch (...) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30870       };
30871     }
30872   }
30873   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30880   bool arg2 ;
30881
30882   arg1 = (Dali::Actor *)jarg1;
30883   arg2 = jarg2 ? true : false;
30884   {
30885     try {
30886       (arg1)->SetInheritOrientation(arg2);
30887     } catch (std::out_of_range& e) {
30888       {
30889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30890       };
30891     } catch (std::exception& e) {
30892       {
30893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30894       };
30895     } catch (...) {
30896       {
30897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30898       };
30899     }
30900   }
30901 }
30902
30903
30904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30905   unsigned int jresult ;
30906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30907   bool result;
30908
30909   arg1 = (Dali::Actor *)jarg1;
30910   {
30911     try {
30912       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30913     } catch (std::out_of_range& e) {
30914       {
30915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (std::exception& e) {
30918       {
30919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927   jresult = result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30933   void * jresult ;
30934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30935   Dali::Quaternion result;
30936
30937   arg1 = (Dali::Actor *)jarg1;
30938   {
30939     try {
30940       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (...) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30952       };
30953     }
30954   }
30955   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30956   return jresult;
30957 }
30958
30959
30960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30962   float arg2 ;
30963
30964   arg1 = (Dali::Actor *)jarg1;
30965   arg2 = (float)jarg2;
30966   {
30967     try {
30968       (arg1)->SetScale(arg2);
30969     } catch (std::out_of_range& e) {
30970       {
30971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30972       };
30973     } catch (std::exception& e) {
30974       {
30975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30976       };
30977     } catch (...) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30980       };
30981     }
30982   }
30983 }
30984
30985
30986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30988   float arg2 ;
30989   float arg3 ;
30990   float arg4 ;
30991
30992   arg1 = (Dali::Actor *)jarg1;
30993   arg2 = (float)jarg2;
30994   arg3 = (float)jarg3;
30995   arg4 = (float)jarg4;
30996   {
30997     try {
30998       (arg1)->SetScale(arg2,arg3,arg4);
30999     } catch (std::out_of_range& e) {
31000       {
31001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31002       };
31003     } catch (std::exception& e) {
31004       {
31005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31006       };
31007     } catch (...) {
31008       {
31009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31010       };
31011     }
31012   }
31013 }
31014
31015
31016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31018   Dali::Vector3 *arg2 = 0 ;
31019
31020   arg1 = (Dali::Actor *)jarg1;
31021   arg2 = (Dali::Vector3 *)jarg2;
31022   if (!arg2) {
31023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31024     return ;
31025   }
31026   {
31027     try {
31028       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31036       };
31037     } catch (...) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31040       };
31041     }
31042   }
31043 }
31044
31045
31046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31048   Dali::Vector3 *arg2 = 0 ;
31049
31050   arg1 = (Dali::Actor *)jarg1;
31051   arg2 = (Dali::Vector3 *)jarg2;
31052   if (!arg2) {
31053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31054     return ;
31055   }
31056   {
31057     try {
31058       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31059     } catch (std::out_of_range& e) {
31060       {
31061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31062       };
31063     } catch (std::exception& e) {
31064       {
31065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31070       };
31071     }
31072   }
31073 }
31074
31075
31076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31077   void * jresult ;
31078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31079   Dali::Vector3 result;
31080
31081   arg1 = (Dali::Actor *)jarg1;
31082   {
31083     try {
31084       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31085     } catch (std::out_of_range& e) {
31086       {
31087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31088       };
31089     } catch (std::exception& e) {
31090       {
31091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31092       };
31093     } catch (...) {
31094       {
31095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31096       };
31097     }
31098   }
31099   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31100   return jresult;
31101 }
31102
31103
31104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31105   void * jresult ;
31106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31107   Dali::Vector3 result;
31108
31109   arg1 = (Dali::Actor *)jarg1;
31110   {
31111     try {
31112       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (...) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31124       };
31125     }
31126   }
31127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31133   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31134   bool arg2 ;
31135
31136   arg1 = (Dali::Actor *)jarg1;
31137   arg2 = jarg2 ? true : false;
31138   {
31139     try {
31140       (arg1)->SetInheritScale(arg2);
31141     } catch (std::out_of_range& e) {
31142       {
31143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31144       };
31145     } catch (std::exception& e) {
31146       {
31147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (...) {
31150       {
31151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31152       };
31153     }
31154   }
31155 }
31156
31157
31158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31159   unsigned int jresult ;
31160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31161   bool result;
31162
31163   arg1 = (Dali::Actor *)jarg1;
31164   {
31165     try {
31166       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31174       };
31175     } catch (...) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31178       };
31179     }
31180   }
31181   jresult = result;
31182   return jresult;
31183 }
31184
31185
31186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31187   void * jresult ;
31188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31189   Dali::Matrix result;
31190
31191   arg1 = (Dali::Actor *)jarg1;
31192   {
31193     try {
31194       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31202       };
31203     } catch (...) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31206       };
31207     }
31208   }
31209   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31210   return jresult;
31211 }
31212
31213
31214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31216   bool arg2 ;
31217
31218   arg1 = (Dali::Actor *)jarg1;
31219   arg2 = jarg2 ? true : false;
31220   {
31221     try {
31222       (arg1)->SetVisible(arg2);
31223     } catch (std::out_of_range& e) {
31224       {
31225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31226       };
31227     } catch (std::exception& e) {
31228       {
31229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31230       };
31231     } catch (...) {
31232       {
31233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31234       };
31235     }
31236   }
31237 }
31238
31239
31240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31241   unsigned int jresult ;
31242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31243   bool result;
31244
31245   arg1 = (Dali::Actor *)jarg1;
31246   {
31247     try {
31248       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31249     } catch (std::out_of_range& e) {
31250       {
31251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31252       };
31253     } catch (std::exception& e) {
31254       {
31255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31256       };
31257     } catch (...) {
31258       {
31259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31260       };
31261     }
31262   }
31263   jresult = result;
31264   return jresult;
31265 }
31266
31267
31268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31270   float arg2 ;
31271
31272   arg1 = (Dali::Actor *)jarg1;
31273   arg2 = (float)jarg2;
31274   {
31275     try {
31276       (arg1)->SetOpacity(arg2);
31277     } catch (std::out_of_range& e) {
31278       {
31279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31280       };
31281     } catch (std::exception& e) {
31282       {
31283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31284       };
31285     } catch (...) {
31286       {
31287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31288       };
31289     }
31290   }
31291 }
31292
31293
31294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31295   float jresult ;
31296   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31297   float result;
31298
31299   arg1 = (Dali::Actor *)jarg1;
31300   {
31301     try {
31302       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31303     } catch (std::out_of_range& e) {
31304       {
31305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31306       };
31307     } catch (std::exception& e) {
31308       {
31309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31310       };
31311     } catch (...) {
31312       {
31313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31314       };
31315     }
31316   }
31317   jresult = result;
31318   return jresult;
31319 }
31320
31321
31322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31324   Dali::Vector4 *arg2 = 0 ;
31325
31326   arg1 = (Dali::Actor *)jarg1;
31327   arg2 = (Dali::Vector4 *)jarg2;
31328   if (!arg2) {
31329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31330     return ;
31331   }
31332   {
31333     try {
31334       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31335     } catch (std::out_of_range& e) {
31336       {
31337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31338       };
31339     } catch (std::exception& e) {
31340       {
31341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31342       };
31343     } catch (...) {
31344       {
31345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31346       };
31347     }
31348   }
31349 }
31350
31351
31352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31353   void * jresult ;
31354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31355   Dali::Vector4 result;
31356
31357   arg1 = (Dali::Actor *)jarg1;
31358   {
31359     try {
31360       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31361     } catch (std::out_of_range& e) {
31362       {
31363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31364       };
31365     } catch (std::exception& e) {
31366       {
31367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (...) {
31370       {
31371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31372       };
31373     }
31374   }
31375   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31376   return jresult;
31377 }
31378
31379
31380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31382   Dali::ColorMode arg2 ;
31383
31384   arg1 = (Dali::Actor *)jarg1;
31385   arg2 = (Dali::ColorMode)jarg2;
31386   {
31387     try {
31388       (arg1)->SetColorMode(arg2);
31389     } catch (std::out_of_range& e) {
31390       {
31391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31392       };
31393     } catch (std::exception& e) {
31394       {
31395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31396       };
31397     } catch (...) {
31398       {
31399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31400       };
31401     }
31402   }
31403 }
31404
31405
31406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31407   int jresult ;
31408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31409   Dali::ColorMode result;
31410
31411   arg1 = (Dali::Actor *)jarg1;
31412   {
31413     try {
31414       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31415     } catch (std::out_of_range& e) {
31416       {
31417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31418       };
31419     } catch (std::exception& e) {
31420       {
31421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31422       };
31423     } catch (...) {
31424       {
31425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31426       };
31427     }
31428   }
31429   jresult = (int)result;
31430   return jresult;
31431 }
31432
31433
31434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31435   void * jresult ;
31436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31437   Dali::Vector4 result;
31438
31439   arg1 = (Dali::Actor *)jarg1;
31440   {
31441     try {
31442       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31443     } catch (std::out_of_range& e) {
31444       {
31445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31446       };
31447     } catch (std::exception& e) {
31448       {
31449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31450       };
31451     } catch (...) {
31452       {
31453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31454       };
31455     }
31456   }
31457   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31458   return jresult;
31459 }
31460
31461
31462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31464   Dali::DrawMode::Type arg2 ;
31465
31466   arg1 = (Dali::Actor *)jarg1;
31467   arg2 = (Dali::DrawMode::Type)jarg2;
31468   {
31469     try {
31470       (arg1)->SetDrawMode(arg2);
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31482       };
31483     }
31484   }
31485 }
31486
31487
31488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31489   int jresult ;
31490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31491   Dali::DrawMode::Type result;
31492
31493   arg1 = (Dali::Actor *)jarg1;
31494   {
31495     try {
31496       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31497     } catch (std::out_of_range& e) {
31498       {
31499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (std::exception& e) {
31502       {
31503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511   jresult = (int)result;
31512   return jresult;
31513 }
31514
31515
31516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31518   bool arg2 ;
31519
31520   arg1 = (Dali::Actor *)jarg1;
31521   arg2 = jarg2 ? true : false;
31522   {
31523     try {
31524       (arg1)->SetSensitive(arg2);
31525     } catch (std::out_of_range& e) {
31526       {
31527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31528       };
31529     } catch (std::exception& e) {
31530       {
31531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31536       };
31537     }
31538   }
31539 }
31540
31541
31542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31543   unsigned int jresult ;
31544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31545   bool result;
31546
31547   arg1 = (Dali::Actor *)jarg1;
31548   {
31549     try {
31550       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (...) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31562       };
31563     }
31564   }
31565   jresult = result;
31566   return jresult;
31567 }
31568
31569
31570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31571   unsigned int jresult ;
31572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31573   float *arg2 = 0 ;
31574   float *arg3 = 0 ;
31575   float arg4 ;
31576   float arg5 ;
31577   bool result;
31578
31579   arg1 = (Dali::Actor *)jarg1;
31580   arg2 = (float *)jarg2;
31581   arg3 = (float *)jarg3;
31582   arg4 = (float)jarg4;
31583   arg5 = (float)jarg5;
31584   {
31585     try {
31586       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31587     } catch (std::out_of_range& e) {
31588       {
31589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31590       };
31591     } catch (std::exception& e) {
31592       {
31593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31594       };
31595     } catch (...) {
31596       {
31597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31598       };
31599     }
31600   }
31601   jresult = result;
31602   return jresult;
31603 }
31604
31605
31606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31608   bool arg2 ;
31609
31610   arg1 = (Dali::Actor *)jarg1;
31611   arg2 = jarg2 ? true : false;
31612   {
31613     try {
31614       (arg1)->SetLeaveRequired(arg2);
31615     } catch (std::out_of_range& e) {
31616       {
31617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31618       };
31619     } catch (std::exception& e) {
31620       {
31621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31622       };
31623     } catch (...) {
31624       {
31625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31626       };
31627     }
31628   }
31629 }
31630
31631
31632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31633   unsigned int jresult ;
31634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31635   bool result;
31636
31637   arg1 = (Dali::Actor *)jarg1;
31638   {
31639     try {
31640       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31641     } catch (std::out_of_range& e) {
31642       {
31643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31644       };
31645     } catch (std::exception& e) {
31646       {
31647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (...) {
31650       {
31651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31652       };
31653     }
31654   }
31655   jresult = result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31662   bool arg2 ;
31663
31664   arg1 = (Dali::Actor *)jarg1;
31665   arg2 = jarg2 ? true : false;
31666   {
31667     try {
31668       (arg1)->SetKeyboardFocusable(arg2);
31669     } catch (std::out_of_range& e) {
31670       {
31671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31672       };
31673     } catch (std::exception& e) {
31674       {
31675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31676       };
31677     } catch (...) {
31678       {
31679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31680       };
31681     }
31682   }
31683 }
31684
31685
31686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31687   unsigned int jresult ;
31688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31689   bool result;
31690
31691   arg1 = (Dali::Actor *)jarg1;
31692   {
31693     try {
31694       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31695     } catch (std::out_of_range& e) {
31696       {
31697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (std::exception& e) {
31700       {
31701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709   jresult = result;
31710   return jresult;
31711 }
31712
31713
31714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31716   Dali::ResizePolicy::Type arg2 ;
31717   Dali::Dimension::Type arg3 ;
31718
31719   arg1 = (Dali::Actor *)jarg1;
31720   arg2 = (Dali::ResizePolicy::Type)jarg2;
31721   arg3 = (Dali::Dimension::Type)jarg3;
31722   {
31723     try {
31724       (arg1)->SetResizePolicy(arg2,arg3);
31725     } catch (std::out_of_range& e) {
31726       {
31727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31728       };
31729     } catch (std::exception& e) {
31730       {
31731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31736       };
31737     }
31738   }
31739 }
31740
31741
31742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31743   int jresult ;
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Dimension::Type arg2 ;
31746   Dali::ResizePolicy::Type result;
31747
31748   arg1 = (Dali::Actor *)jarg1;
31749   arg2 = (Dali::Dimension::Type)jarg2;
31750   {
31751     try {
31752       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31753     } catch (std::out_of_range& e) {
31754       {
31755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31756       };
31757     } catch (std::exception& e) {
31758       {
31759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (...) {
31762       {
31763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31764       };
31765     }
31766   }
31767   jresult = (int)result;
31768   return jresult;
31769 }
31770
31771
31772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31774   Dali::SizeScalePolicy::Type arg2 ;
31775
31776   arg1 = (Dali::Actor *)jarg1;
31777   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31778   {
31779     try {
31780       (arg1)->SetSizeScalePolicy(arg2);
31781     } catch (std::out_of_range& e) {
31782       {
31783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31784       };
31785     } catch (std::exception& e) {
31786       {
31787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31788       };
31789     } catch (...) {
31790       {
31791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31792       };
31793     }
31794   }
31795 }
31796
31797
31798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31799   int jresult ;
31800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31801   Dali::SizeScalePolicy::Type result;
31802
31803   arg1 = (Dali::Actor *)jarg1;
31804   {
31805     try {
31806       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31807     } catch (std::out_of_range& e) {
31808       {
31809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (std::exception& e) {
31812       {
31813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821   jresult = (int)result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31828   Dali::Vector3 *arg2 = 0 ;
31829
31830   arg1 = (Dali::Actor *)jarg1;
31831   arg2 = (Dali::Vector3 *)jarg2;
31832   if (!arg2) {
31833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31834     return ;
31835   }
31836   {
31837     try {
31838       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31839     } catch (std::out_of_range& e) {
31840       {
31841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31842       };
31843     } catch (std::exception& e) {
31844       {
31845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31850       };
31851     }
31852   }
31853 }
31854
31855
31856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31857   void * jresult ;
31858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31859   Dali::Vector3 result;
31860
31861   arg1 = (Dali::Actor *)jarg1;
31862   {
31863     try {
31864       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31865     } catch (std::out_of_range& e) {
31866       {
31867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31868       };
31869     } catch (std::exception& e) {
31870       {
31871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (...) {
31874       {
31875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31876       };
31877     }
31878   }
31879   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31880   return jresult;
31881 }
31882
31883
31884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31885   float jresult ;
31886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31887   float arg2 ;
31888   float result;
31889
31890   arg1 = (Dali::Actor *)jarg1;
31891   arg2 = (float)jarg2;
31892   {
31893     try {
31894       result = (float)(arg1)->GetHeightForWidth(arg2);
31895     } catch (std::out_of_range& e) {
31896       {
31897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31898       };
31899     } catch (std::exception& e) {
31900       {
31901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31902       };
31903     } catch (...) {
31904       {
31905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31906       };
31907     }
31908   }
31909   jresult = result;
31910   return jresult;
31911 }
31912
31913
31914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31915   float jresult ;
31916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31917   float arg2 ;
31918   float result;
31919
31920   arg1 = (Dali::Actor *)jarg1;
31921   arg2 = (float)jarg2;
31922   {
31923     try {
31924       result = (float)(arg1)->GetWidthForHeight(arg2);
31925     } catch (std::out_of_range& e) {
31926       {
31927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31928       };
31929     } catch (std::exception& e) {
31930       {
31931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31932       };
31933     } catch (...) {
31934       {
31935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31936       };
31937     }
31938   }
31939   jresult = result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31945   float jresult ;
31946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31947   Dali::Dimension::Type arg2 ;
31948   float result;
31949
31950   arg1 = (Dali::Actor *)jarg1;
31951   arg2 = (Dali::Dimension::Type)jarg2;
31952   {
31953     try {
31954       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31955     } catch (std::out_of_range& e) {
31956       {
31957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31958       };
31959     } catch (std::exception& e) {
31960       {
31961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (...) {
31964       {
31965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31966       };
31967     }
31968   }
31969   jresult = result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31976   Dali::Padding *arg2 = 0 ;
31977
31978   arg1 = (Dali::Actor *)jarg1;
31979   arg2 = (Dali::Padding *)jarg2;
31980   if (!arg2) {
31981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31982     return ;
31983   }
31984   {
31985     try {
31986       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31987     } catch (std::out_of_range& e) {
31988       {
31989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31990       };
31991     } catch (std::exception& e) {
31992       {
31993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31994       };
31995     } catch (...) {
31996       {
31997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31998       };
31999     }
32000   }
32001 }
32002
32003
32004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32006   Dali::Padding *arg2 = 0 ;
32007
32008   arg1 = (Dali::Actor *)jarg1;
32009   arg2 = (Dali::Padding *)jarg2;
32010   if (!arg2) {
32011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32012     return ;
32013   }
32014   {
32015     try {
32016       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32017     } catch (std::out_of_range& e) {
32018       {
32019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32020       };
32021     } catch (std::exception& e) {
32022       {
32023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32024       };
32025     } catch (...) {
32026       {
32027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32028       };
32029     }
32030   }
32031 }
32032
32033
32034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32036   Dali::Vector2 *arg2 = 0 ;
32037
32038   arg1 = (Dali::Actor *)jarg1;
32039   arg2 = (Dali::Vector2 *)jarg2;
32040   if (!arg2) {
32041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32042     return ;
32043   }
32044   {
32045     try {
32046       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32047     } catch (std::out_of_range& e) {
32048       {
32049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32050       };
32051     } catch (std::exception& e) {
32052       {
32053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32054       };
32055     } catch (...) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32058       };
32059     }
32060   }
32061 }
32062
32063
32064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32065   void * jresult ;
32066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32067   Dali::Vector2 result;
32068
32069   arg1 = (Dali::Actor *)jarg1;
32070   {
32071     try {
32072       result = (arg1)->GetMinimumSize();
32073     } catch (std::out_of_range& e) {
32074       {
32075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32076       };
32077     } catch (std::exception& e) {
32078       {
32079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32080       };
32081     } catch (...) {
32082       {
32083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32084       };
32085     }
32086   }
32087   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32094   Dali::Vector2 *arg2 = 0 ;
32095
32096   arg1 = (Dali::Actor *)jarg1;
32097   arg2 = (Dali::Vector2 *)jarg2;
32098   if (!arg2) {
32099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32100     return ;
32101   }
32102   {
32103     try {
32104       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32105     } catch (std::out_of_range& e) {
32106       {
32107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32108       };
32109     } catch (std::exception& e) {
32110       {
32111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32112       };
32113     } catch (...) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32116       };
32117     }
32118   }
32119 }
32120
32121
32122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32123   void * jresult ;
32124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32125   Dali::Vector2 result;
32126
32127   arg1 = (Dali::Actor *)jarg1;
32128   {
32129     try {
32130       result = (arg1)->GetMaximumSize();
32131     } catch (std::out_of_range& e) {
32132       {
32133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32134       };
32135     } catch (std::exception& e) {
32136       {
32137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32138       };
32139     } catch (...) {
32140       {
32141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32142       };
32143     }
32144   }
32145   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32146   return jresult;
32147 }
32148
32149
32150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32151   int jresult ;
32152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32153   int result;
32154
32155   arg1 = (Dali::Actor *)jarg1;
32156   {
32157     try {
32158       result = (int)(arg1)->GetHierarchyDepth();
32159     } catch (std::out_of_range& e) {
32160       {
32161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32162       };
32163     } catch (std::exception& e) {
32164       {
32165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32166       };
32167     } catch (...) {
32168       {
32169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32170       };
32171     }
32172   }
32173   jresult = result;
32174   return jresult;
32175 }
32176
32177
32178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32179   unsigned int jresult ;
32180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32181   Dali::Renderer *arg2 = 0 ;
32182   unsigned int result;
32183
32184   arg1 = (Dali::Actor *)jarg1;
32185   arg2 = (Dali::Renderer *)jarg2;
32186   if (!arg2) {
32187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32188     return 0;
32189   }
32190   {
32191     try {
32192       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32193     } catch (std::out_of_range& e) {
32194       {
32195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32196       };
32197     } catch (std::exception& e) {
32198       {
32199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32200       };
32201     } catch (...) {
32202       {
32203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32204       };
32205     }
32206   }
32207   jresult = result;
32208   return jresult;
32209 }
32210
32211
32212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32213   unsigned int jresult ;
32214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32215   unsigned int result;
32216
32217   arg1 = (Dali::Actor *)jarg1;
32218   {
32219     try {
32220       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32221     } catch (std::out_of_range& e) {
32222       {
32223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32224       };
32225     } catch (std::exception& e) {
32226       {
32227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32228       };
32229     } catch (...) {
32230       {
32231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32232       };
32233     }
32234   }
32235   jresult = result;
32236   return jresult;
32237 }
32238
32239
32240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32241   void * jresult ;
32242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32243   unsigned int arg2 ;
32244   Dali::Renderer result;
32245
32246   arg1 = (Dali::Actor *)jarg1;
32247   arg2 = (unsigned int)jarg2;
32248   {
32249     try {
32250       result = (arg1)->GetRendererAt(arg2);
32251     } catch (std::out_of_range& e) {
32252       {
32253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (std::exception& e) {
32256       {
32257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32266   return jresult;
32267 }
32268
32269
32270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32272   Dali::Renderer *arg2 = 0 ;
32273
32274   arg1 = (Dali::Actor *)jarg1;
32275   arg2 = (Dali::Renderer *)jarg2;
32276   if (!arg2) {
32277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32278     return ;
32279   }
32280   {
32281     try {
32282       (arg1)->RemoveRenderer(*arg2);
32283     } catch (std::out_of_range& e) {
32284       {
32285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32286       };
32287     } catch (std::exception& e) {
32288       {
32289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32294       };
32295     }
32296   }
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32302   unsigned int arg2 ;
32303
32304   arg1 = (Dali::Actor *)jarg1;
32305   arg2 = (unsigned int)jarg2;
32306   {
32307     try {
32308       (arg1)->RemoveRenderer(arg2);
32309     } catch (std::out_of_range& e) {
32310       {
32311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32312       };
32313     } catch (std::exception& e) {
32314       {
32315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32320       };
32321     }
32322   }
32323 }
32324
32325
32326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32327   void * jresult ;
32328   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32329   Dali::Actor::TouchSignalType *result = 0 ;
32330
32331   arg1 = (Dali::Actor *)jarg1;
32332   {
32333     try {
32334       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32335     } catch (std::out_of_range& e) {
32336       {
32337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32338       };
32339     } catch (std::exception& e) {
32340       {
32341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32346       };
32347     }
32348   }
32349   jresult = (void *)result;
32350   return jresult;
32351 }
32352
32353
32354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32355   void * jresult ;
32356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32357   Dali::Actor::TouchDataSignalType *result = 0 ;
32358
32359   arg1 = (Dali::Actor *)jarg1;
32360   {
32361     try {
32362       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32363     } catch (std::out_of_range& e) {
32364       {
32365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32366       };
32367     } catch (std::exception& e) {
32368       {
32369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32370       };
32371     } catch (...) {
32372       {
32373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32374       };
32375     }
32376   }
32377   jresult = (void *)result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32383   void * jresult ;
32384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32385   Dali::Actor::HoverSignalType *result = 0 ;
32386
32387   arg1 = (Dali::Actor *)jarg1;
32388   {
32389     try {
32390       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (...) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32402       };
32403     }
32404   }
32405   jresult = (void *)result;
32406   return jresult;
32407 }
32408
32409
32410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32411   void * jresult ;
32412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32413   Dali::Actor::WheelEventSignalType *result = 0 ;
32414
32415   arg1 = (Dali::Actor *)jarg1;
32416   {
32417     try {
32418       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32419     } catch (std::out_of_range& e) {
32420       {
32421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32422       };
32423     } catch (std::exception& e) {
32424       {
32425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32426       };
32427     } catch (...) {
32428       {
32429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32430       };
32431     }
32432   }
32433   jresult = (void *)result;
32434   return jresult;
32435 }
32436
32437
32438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32439   void * jresult ;
32440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32441   Dali::Actor::OnStageSignalType *result = 0 ;
32442
32443   arg1 = (Dali::Actor *)jarg1;
32444   {
32445     try {
32446       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32447     } catch (std::out_of_range& e) {
32448       {
32449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (std::exception& e) {
32452       {
32453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32458       };
32459     }
32460   }
32461   jresult = (void *)result;
32462   return jresult;
32463 }
32464
32465
32466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32467   void * jresult ;
32468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32469   Dali::Actor::OffStageSignalType *result = 0 ;
32470
32471   arg1 = (Dali::Actor *)jarg1;
32472   {
32473     try {
32474       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32475     } catch (std::out_of_range& e) {
32476       {
32477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32478       };
32479     } catch (std::exception& e) {
32480       {
32481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32482       };
32483     } catch (...) {
32484       {
32485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32486       };
32487     }
32488   }
32489   jresult = (void *)result;
32490   return jresult;
32491 }
32492
32493
32494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32495   void * jresult ;
32496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32497   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32498
32499   arg1 = (Dali::Actor *)jarg1;
32500   {
32501     try {
32502       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32503     } catch (std::out_of_range& e) {
32504       {
32505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (std::exception& e) {
32508       {
32509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32510       };
32511     } catch (...) {
32512       {
32513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32514       };
32515     }
32516   }
32517   jresult = (void *)result;
32518   return jresult;
32519 }
32520
32521
32522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32523   Dali::Actor *arg1 = 0 ;
32524
32525   arg1 = (Dali::Actor *)jarg1;
32526   if (!arg1) {
32527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32528     return ;
32529   }
32530   {
32531     try {
32532       Dali::UnparentAndReset(*arg1);
32533     } catch (std::out_of_range& e) {
32534       {
32535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32536       };
32537     } catch (std::exception& e) {
32538       {
32539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32540       };
32541     } catch (...) {
32542       {
32543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32544       };
32545     }
32546   }
32547 }
32548
32549
32550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32551   int jresult ;
32552   int result;
32553
32554   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32555   jresult = (int)result;
32556   return jresult;
32557 }
32558
32559
32560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32561   int jresult ;
32562   int result;
32563
32564   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32565   jresult = (int)result;
32566   return jresult;
32567 }
32568
32569
32570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32571   int jresult ;
32572   int result;
32573
32574   result = (int)Dali::Layer::Property::BEHAVIOR;
32575   jresult = (int)result;
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32581   void * jresult ;
32582   Dali::Layer::Property *result = 0 ;
32583
32584   {
32585     try {
32586       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32587     } catch (std::out_of_range& e) {
32588       {
32589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32590       };
32591     } catch (std::exception& e) {
32592       {
32593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32594       };
32595     } catch (...) {
32596       {
32597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32598       };
32599     }
32600   }
32601   jresult = (void *)result;
32602   return jresult;
32603 }
32604
32605
32606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32607   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32608
32609   arg1 = (Dali::Layer::Property *)jarg1;
32610   {
32611     try {
32612       delete arg1;
32613     } catch (std::out_of_range& e) {
32614       {
32615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32616       };
32617     } catch (std::exception& e) {
32618       {
32619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32624       };
32625     }
32626   }
32627 }
32628
32629
32630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32631   void * jresult ;
32632   Dali::Layer *result = 0 ;
32633
32634   {
32635     try {
32636       result = (Dali::Layer *)new Dali::Layer();
32637     } catch (std::out_of_range& e) {
32638       {
32639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32640       };
32641     } catch (std::exception& e) {
32642       {
32643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32644       };
32645     } catch (...) {
32646       {
32647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32648       };
32649     }
32650   }
32651   jresult = (void *)result;
32652   return jresult;
32653 }
32654
32655
32656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32657   void * jresult ;
32658   Dali::Layer result;
32659
32660   {
32661     try {
32662       result = Dali::Layer::New();
32663     } catch (std::out_of_range& e) {
32664       {
32665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32666       };
32667     } catch (std::exception& e) {
32668       {
32669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32670       };
32671     } catch (...) {
32672       {
32673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32674       };
32675     }
32676   }
32677   jresult = new Dali::Layer((const Dali::Layer &)result);
32678   return jresult;
32679 }
32680
32681
32682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32683   void * jresult ;
32684   Dali::BaseHandle arg1 ;
32685   Dali::BaseHandle *argp1 ;
32686   Dali::Layer result;
32687
32688   argp1 = (Dali::BaseHandle *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32691     return 0;
32692   }
32693   arg1 = *argp1;
32694   {
32695     try {
32696       result = Dali::Layer::DownCast(arg1);
32697     } catch (std::out_of_range& e) {
32698       {
32699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32700       };
32701     } catch (std::exception& e) {
32702       {
32703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32704       };
32705     } catch (...) {
32706       {
32707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32708       };
32709     }
32710   }
32711   jresult = new Dali::Layer((const Dali::Layer &)result);
32712   return jresult;
32713 }
32714
32715
32716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32718
32719   arg1 = (Dali::Layer *)jarg1;
32720   {
32721     try {
32722       delete arg1;
32723     } catch (std::out_of_range& e) {
32724       {
32725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (std::exception& e) {
32728       {
32729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32734       };
32735     }
32736   }
32737 }
32738
32739
32740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32741   void * jresult ;
32742   Dali::Layer *arg1 = 0 ;
32743   Dali::Layer *result = 0 ;
32744
32745   arg1 = (Dali::Layer *)jarg1;
32746   if (!arg1) {
32747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32748     return 0;
32749   }
32750   {
32751     try {
32752       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32760       };
32761     } catch (...) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32764       };
32765     }
32766   }
32767   jresult = (void *)result;
32768   return jresult;
32769 }
32770
32771
32772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32773   void * jresult ;
32774   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32775   Dali::Layer *arg2 = 0 ;
32776   Dali::Layer *result = 0 ;
32777
32778   arg1 = (Dali::Layer *)jarg1;
32779   arg2 = (Dali::Layer *)jarg2;
32780   if (!arg2) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32782     return 0;
32783   }
32784   {
32785     try {
32786       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32787     } catch (std::out_of_range& e) {
32788       {
32789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (std::exception& e) {
32792       {
32793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801   jresult = (void *)result;
32802   return jresult;
32803 }
32804
32805
32806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32807   unsigned int jresult ;
32808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32809   unsigned int result;
32810
32811   arg1 = (Dali::Layer *)jarg1;
32812   {
32813     try {
32814       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32815     } catch (std::out_of_range& e) {
32816       {
32817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32818       };
32819     } catch (std::exception& e) {
32820       {
32821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32822       };
32823     } catch (...) {
32824       {
32825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32826       };
32827     }
32828   }
32829   jresult = result;
32830   return jresult;
32831 }
32832
32833
32834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32835   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32836
32837   arg1 = (Dali::Layer *)jarg1;
32838   {
32839     try {
32840       (arg1)->Raise();
32841     } catch (std::out_of_range& e) {
32842       {
32843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (std::exception& e) {
32846       {
32847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855 }
32856
32857
32858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32859   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32860
32861   arg1 = (Dali::Layer *)jarg1;
32862   {
32863     try {
32864       (arg1)->Lower();
32865     } catch (std::out_of_range& e) {
32866       {
32867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32868       };
32869     } catch (std::exception& e) {
32870       {
32871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32872       };
32873     } catch (...) {
32874       {
32875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32876       };
32877     }
32878   }
32879 }
32880
32881
32882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32883   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32884   Dali::Layer arg2 ;
32885   Dali::Layer *argp2 ;
32886
32887   arg1 = (Dali::Layer *)jarg1;
32888   argp2 = (Dali::Layer *)jarg2;
32889   if (!argp2) {
32890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32891     return ;
32892   }
32893   arg2 = *argp2;
32894   {
32895     try {
32896       (arg1)->RaiseAbove(arg2);
32897     } catch (std::out_of_range& e) {
32898       {
32899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32900       };
32901     } catch (std::exception& e) {
32902       {
32903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32904       };
32905     } catch (...) {
32906       {
32907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32908       };
32909     }
32910   }
32911 }
32912
32913
32914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32915   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32916   Dali::Layer arg2 ;
32917   Dali::Layer *argp2 ;
32918
32919   arg1 = (Dali::Layer *)jarg1;
32920   argp2 = (Dali::Layer *)jarg2;
32921   if (!argp2) {
32922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32923     return ;
32924   }
32925   arg2 = *argp2;
32926   {
32927     try {
32928       (arg1)->LowerBelow(arg2);
32929     } catch (std::out_of_range& e) {
32930       {
32931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32932       };
32933     } catch (std::exception& e) {
32934       {
32935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32936       };
32937     } catch (...) {
32938       {
32939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32940       };
32941     }
32942   }
32943 }
32944
32945
32946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32947   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32948
32949   arg1 = (Dali::Layer *)jarg1;
32950   {
32951     try {
32952       (arg1)->RaiseToTop();
32953     } catch (std::out_of_range& e) {
32954       {
32955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32956       };
32957     } catch (std::exception& e) {
32958       {
32959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32960       };
32961     } catch (...) {
32962       {
32963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32964       };
32965     }
32966   }
32967 }
32968
32969
32970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32971   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32972
32973   arg1 = (Dali::Layer *)jarg1;
32974   {
32975     try {
32976       (arg1)->LowerToBottom();
32977     } catch (std::out_of_range& e) {
32978       {
32979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32980       };
32981     } catch (std::exception& e) {
32982       {
32983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32984       };
32985     } catch (...) {
32986       {
32987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32988       };
32989     }
32990   }
32991 }
32992
32993
32994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32995   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32996   Dali::Layer arg2 ;
32997   Dali::Layer *argp2 ;
32998
32999   arg1 = (Dali::Layer *)jarg1;
33000   argp2 = (Dali::Layer *)jarg2;
33001   if (!argp2) {
33002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33003     return ;
33004   }
33005   arg2 = *argp2;
33006   {
33007     try {
33008       (arg1)->MoveAbove(arg2);
33009     } catch (std::out_of_range& e) {
33010       {
33011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33012       };
33013     } catch (std::exception& e) {
33014       {
33015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33016       };
33017     } catch (...) {
33018       {
33019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33020       };
33021     }
33022   }
33023 }
33024
33025
33026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33027   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33028   Dali::Layer arg2 ;
33029   Dali::Layer *argp2 ;
33030
33031   arg1 = (Dali::Layer *)jarg1;
33032   argp2 = (Dali::Layer *)jarg2;
33033   if (!argp2) {
33034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33035     return ;
33036   }
33037   arg2 = *argp2;
33038   {
33039     try {
33040       (arg1)->MoveBelow(arg2);
33041     } catch (std::out_of_range& e) {
33042       {
33043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33044       };
33045     } catch (std::exception& e) {
33046       {
33047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33048       };
33049     } catch (...) {
33050       {
33051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33052       };
33053     }
33054   }
33055 }
33056
33057
33058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33059   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33060   Dali::Layer::Behavior arg2 ;
33061
33062   arg1 = (Dali::Layer *)jarg1;
33063   arg2 = (Dali::Layer::Behavior)jarg2;
33064   {
33065     try {
33066       (arg1)->SetBehavior(arg2);
33067     } catch (std::out_of_range& e) {
33068       {
33069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33070       };
33071     } catch (std::exception& e) {
33072       {
33073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33074       };
33075     } catch (...) {
33076       {
33077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33078       };
33079     }
33080   }
33081 }
33082
33083
33084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33085   int jresult ;
33086   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33087   Dali::Layer::Behavior result;
33088
33089   arg1 = (Dali::Layer *)jarg1;
33090   {
33091     try {
33092       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33093     } catch (std::out_of_range& e) {
33094       {
33095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33096       };
33097     } catch (std::exception& e) {
33098       {
33099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33100       };
33101     } catch (...) {
33102       {
33103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33104       };
33105     }
33106   }
33107   jresult = (int)result;
33108   return jresult;
33109 }
33110
33111
33112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33113   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33114   bool arg2 ;
33115
33116   arg1 = (Dali::Layer *)jarg1;
33117   arg2 = jarg2 ? true : false;
33118   {
33119     try {
33120       (arg1)->SetClipping(arg2);
33121     } catch (std::out_of_range& e) {
33122       {
33123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33124       };
33125     } catch (std::exception& e) {
33126       {
33127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33128       };
33129     } catch (...) {
33130       {
33131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33132       };
33133     }
33134   }
33135 }
33136
33137
33138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33139   unsigned int jresult ;
33140   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33141   bool result;
33142
33143   arg1 = (Dali::Layer *)jarg1;
33144   {
33145     try {
33146       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33147     } catch (std::out_of_range& e) {
33148       {
33149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33150       };
33151     } catch (std::exception& e) {
33152       {
33153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33154       };
33155     } catch (...) {
33156       {
33157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33158       };
33159     }
33160   }
33161   jresult = result;
33162   return jresult;
33163 }
33164
33165
33166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33167   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33168   int arg2 ;
33169   int arg3 ;
33170   int arg4 ;
33171   int arg5 ;
33172
33173   arg1 = (Dali::Layer *)jarg1;
33174   arg2 = (int)jarg2;
33175   arg3 = (int)jarg3;
33176   arg4 = (int)jarg4;
33177   arg5 = (int)jarg5;
33178   {
33179     try {
33180       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33181     } catch (std::out_of_range& e) {
33182       {
33183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33184       };
33185     } catch (std::exception& e) {
33186       {
33187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33188       };
33189     } catch (...) {
33190       {
33191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33192       };
33193     }
33194   }
33195 }
33196
33197
33198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33199   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33200   Dali::ClippingBox arg2 ;
33201   Dali::ClippingBox *argp2 ;
33202
33203   arg1 = (Dali::Layer *)jarg1;
33204   argp2 = (Dali::ClippingBox *)jarg2;
33205   if (!argp2) {
33206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33207     return ;
33208   }
33209   arg2 = *argp2;
33210   {
33211     try {
33212       (arg1)->SetClippingBox(arg2);
33213     } catch (std::out_of_range& e) {
33214       {
33215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33216       };
33217     } catch (std::exception& e) {
33218       {
33219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33220       };
33221     } catch (...) {
33222       {
33223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33224       };
33225     }
33226   }
33227 }
33228
33229
33230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33231   void * jresult ;
33232   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33233   Dali::ClippingBox result;
33234
33235   arg1 = (Dali::Layer *)jarg1;
33236   {
33237     try {
33238       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33239     } catch (std::out_of_range& e) {
33240       {
33241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33242       };
33243     } catch (std::exception& e) {
33244       {
33245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33246       };
33247     } catch (...) {
33248       {
33249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33250       };
33251     }
33252   }
33253   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33259   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33260   bool arg2 ;
33261
33262   arg1 = (Dali::Layer *)jarg1;
33263   arg2 = jarg2 ? true : false;
33264   {
33265     try {
33266       (arg1)->SetDepthTestDisabled(arg2);
33267     } catch (std::out_of_range& e) {
33268       {
33269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33270       };
33271     } catch (std::exception& e) {
33272       {
33273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33274       };
33275     } catch (...) {
33276       {
33277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33278       };
33279     }
33280   }
33281 }
33282
33283
33284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33285   unsigned int jresult ;
33286   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33287   bool result;
33288
33289   arg1 = (Dali::Layer *)jarg1;
33290   {
33291     try {
33292       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33293     } catch (std::out_of_range& e) {
33294       {
33295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (std::exception& e) {
33298       {
33299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33300       };
33301     } catch (...) {
33302       {
33303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33304       };
33305     }
33306   }
33307   jresult = result;
33308   return jresult;
33309 }
33310
33311
33312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33313   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33314   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33315
33316   arg1 = (Dali::Layer *)jarg1;
33317   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33318   {
33319     try {
33320       (arg1)->SetSortFunction(arg2);
33321     } catch (std::out_of_range& e) {
33322       {
33323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33324       };
33325     } catch (std::exception& e) {
33326       {
33327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33328       };
33329     } catch (...) {
33330       {
33331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33332       };
33333     }
33334   }
33335 }
33336
33337
33338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33339   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33340   bool arg2 ;
33341
33342   arg1 = (Dali::Layer *)jarg1;
33343   arg2 = jarg2 ? true : false;
33344   {
33345     try {
33346       (arg1)->SetTouchConsumed(arg2);
33347     } catch (std::out_of_range& e) {
33348       {
33349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33350       };
33351     } catch (std::exception& e) {
33352       {
33353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33354       };
33355     } catch (...) {
33356       {
33357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33358       };
33359     }
33360   }
33361 }
33362
33363
33364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33365   unsigned int jresult ;
33366   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33367   bool result;
33368
33369   arg1 = (Dali::Layer *)jarg1;
33370   {
33371     try {
33372       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
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 = result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33393   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33394   bool arg2 ;
33395
33396   arg1 = (Dali::Layer *)jarg1;
33397   arg2 = jarg2 ? true : false;
33398   {
33399     try {
33400       (arg1)->SetHoverConsumed(arg2);
33401     } catch (std::out_of_range& e) {
33402       {
33403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33404       };
33405     } catch (std::exception& e) {
33406       {
33407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33408       };
33409     } catch (...) {
33410       {
33411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33412       };
33413     }
33414   }
33415 }
33416
33417
33418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33419   unsigned int jresult ;
33420   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33421   bool result;
33422
33423   arg1 = (Dali::Layer *)jarg1;
33424   {
33425     try {
33426       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33427     } catch (std::out_of_range& e) {
33428       {
33429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33430       };
33431     } catch (std::exception& e) {
33432       {
33433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (...) {
33436       {
33437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33438       };
33439     }
33440   }
33441   jresult = result;
33442   return jresult;
33443 }
33444
33445
33446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33447   void * jresult ;
33448   Dali::Vector4 *result = 0 ;
33449
33450   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33451   jresult = (void *)result;
33452   return jresult;
33453 }
33454
33455
33456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33457   void * jresult ;
33458   Dali::Vector4 *result = 0 ;
33459
33460   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33461   jresult = (void *)result;
33462   return jresult;
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33467   void * jresult ;
33468   Dali::Stage *result = 0 ;
33469
33470   {
33471     try {
33472       result = (Dali::Stage *)new Dali::Stage();
33473     } catch (std::out_of_range& e) {
33474       {
33475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (std::exception& e) {
33478       {
33479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33493   void * jresult ;
33494   Dali::Stage result;
33495
33496   {
33497     try {
33498       result = Dali::Stage::GetCurrent();
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (...) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33510       };
33511     }
33512   }
33513   jresult = new Dali::Stage((const Dali::Stage &)result);
33514   return jresult;
33515 }
33516
33517
33518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33519   unsigned int jresult ;
33520   bool result;
33521
33522   {
33523     try {
33524       result = (bool)Dali::Stage::IsInstalled();
33525     } catch (std::out_of_range& e) {
33526       {
33527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33528       };
33529     } catch (std::exception& e) {
33530       {
33531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33532       };
33533     } catch (...) {
33534       {
33535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33536       };
33537     }
33538   }
33539   jresult = result;
33540   return jresult;
33541 }
33542
33543
33544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33545   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33546
33547   arg1 = (Dali::Stage *)jarg1;
33548   {
33549     try {
33550       delete arg1;
33551     } catch (std::out_of_range& e) {
33552       {
33553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33554       };
33555     } catch (std::exception& e) {
33556       {
33557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33558       };
33559     } catch (...) {
33560       {
33561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33562       };
33563     }
33564   }
33565 }
33566
33567
33568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33569   void * jresult ;
33570   Dali::Stage *arg1 = 0 ;
33571   Dali::Stage *result = 0 ;
33572
33573   arg1 = (Dali::Stage *)jarg1;
33574   if (!arg1) {
33575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33576     return 0;
33577   }
33578   {
33579     try {
33580       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33581     } catch (std::out_of_range& e) {
33582       {
33583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (std::exception& e) {
33586       {
33587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595   jresult = (void *)result;
33596   return jresult;
33597 }
33598
33599
33600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33601   void * jresult ;
33602   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33603   Dali::Stage *arg2 = 0 ;
33604   Dali::Stage *result = 0 ;
33605
33606   arg1 = (Dali::Stage *)jarg1;
33607   arg2 = (Dali::Stage *)jarg2;
33608   if (!arg2) {
33609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33610     return 0;
33611   }
33612   {
33613     try {
33614       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33615     } catch (std::out_of_range& e) {
33616       {
33617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33618       };
33619     } catch (std::exception& e) {
33620       {
33621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (...) {
33624       {
33625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33626       };
33627     }
33628   }
33629   jresult = (void *)result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33636   Dali::Actor *arg2 = 0 ;
33637
33638   arg1 = (Dali::Stage *)jarg1;
33639   arg2 = (Dali::Actor *)jarg2;
33640   if (!arg2) {
33641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33642     return ;
33643   }
33644   {
33645     try {
33646       (arg1)->Add(*arg2);
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33658       };
33659     }
33660   }
33661 }
33662
33663
33664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33665   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33666   Dali::Actor *arg2 = 0 ;
33667
33668   arg1 = (Dali::Stage *)jarg1;
33669   arg2 = (Dali::Actor *)jarg2;
33670   if (!arg2) {
33671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33672     return ;
33673   }
33674   {
33675     try {
33676       (arg1)->Remove(*arg2);
33677     } catch (std::out_of_range& e) {
33678       {
33679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33680       };
33681     } catch (std::exception& e) {
33682       {
33683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33684       };
33685     } catch (...) {
33686       {
33687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33688       };
33689     }
33690   }
33691 }
33692
33693
33694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33695   void * jresult ;
33696   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33697   Dali::Vector2 result;
33698
33699   arg1 = (Dali::Stage *)jarg1;
33700   {
33701     try {
33702       result = ((Dali::Stage const *)arg1)->GetSize();
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33714       };
33715     }
33716   }
33717   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33718   return jresult;
33719 }
33720
33721
33722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33723   void * jresult ;
33724   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33725   Dali::RenderTaskList result;
33726
33727   arg1 = (Dali::Stage *)jarg1;
33728   {
33729     try {
33730       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33731     } catch (std::out_of_range& e) {
33732       {
33733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (std::exception& e) {
33736       {
33737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33742       };
33743     }
33744   }
33745   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33746   return jresult;
33747 }
33748
33749
33750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33751   unsigned int jresult ;
33752   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33753   unsigned int result;
33754
33755   arg1 = (Dali::Stage *)jarg1;
33756   {
33757     try {
33758       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33759     } catch (std::out_of_range& e) {
33760       {
33761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33762       };
33763     } catch (std::exception& e) {
33764       {
33765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33766       };
33767     } catch (...) {
33768       {
33769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33770       };
33771     }
33772   }
33773   jresult = result;
33774   return jresult;
33775 }
33776
33777
33778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33779   void * jresult ;
33780   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33781   unsigned int arg2 ;
33782   Dali::Layer result;
33783
33784   arg1 = (Dali::Stage *)jarg1;
33785   arg2 = (unsigned int)jarg2;
33786   {
33787     try {
33788       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803   jresult = new Dali::Layer((const Dali::Layer &)result);
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33809   void * jresult ;
33810   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33811   Dali::Layer result;
33812
33813   arg1 = (Dali::Stage *)jarg1;
33814   {
33815     try {
33816       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (...) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33828       };
33829     }
33830   }
33831   jresult = new Dali::Layer((const Dali::Layer &)result);
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33838   Dali::Vector4 arg2 ;
33839   Dali::Vector4 *argp2 ;
33840
33841   arg1 = (Dali::Stage *)jarg1;
33842   argp2 = (Dali::Vector4 *)jarg2;
33843   if (!argp2) {
33844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33845     return ;
33846   }
33847   arg2 = *argp2;
33848   {
33849     try {
33850       (arg1)->SetBackgroundColor(arg2);
33851     } catch (std::out_of_range& e) {
33852       {
33853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33854       };
33855     } catch (std::exception& e) {
33856       {
33857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33862       };
33863     }
33864   }
33865 }
33866
33867
33868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33869   void * jresult ;
33870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33871   Dali::Vector4 result;
33872
33873   arg1 = (Dali::Stage *)jarg1;
33874   {
33875     try {
33876       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33877     } catch (std::out_of_range& e) {
33878       {
33879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (std::exception& e) {
33882       {
33883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33884       };
33885     } catch (...) {
33886       {
33887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33888       };
33889     }
33890   }
33891   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33897   void * jresult ;
33898   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33899   Dali::Vector2 result;
33900
33901   arg1 = (Dali::Stage *)jarg1;
33902   {
33903     try {
33904       result = ((Dali::Stage const *)arg1)->GetDpi();
33905     } catch (std::out_of_range& e) {
33906       {
33907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33908       };
33909     } catch (std::exception& e) {
33910       {
33911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33912       };
33913     } catch (...) {
33914       {
33915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33916       };
33917     }
33918   }
33919   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33920   return jresult;
33921 }
33922
33923
33924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33925   void * jresult ;
33926   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33927   Dali::ObjectRegistry result;
33928
33929   arg1 = (Dali::Stage *)jarg1;
33930   {
33931     try {
33932       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33933     } catch (std::out_of_range& e) {
33934       {
33935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33936       };
33937     } catch (std::exception& e) {
33938       {
33939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33940       };
33941     } catch (...) {
33942       {
33943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33944       };
33945     }
33946   }
33947   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33948   return jresult;
33949 }
33950
33951
33952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33953   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33954   float arg2 ;
33955
33956   arg1 = (Dali::Stage *)jarg1;
33957   arg2 = (float)jarg2;
33958   {
33959     try {
33960       (arg1)->KeepRendering(arg2);
33961     } catch (std::out_of_range& e) {
33962       {
33963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33964       };
33965     } catch (std::exception& e) {
33966       {
33967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33968       };
33969     } catch (...) {
33970       {
33971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33972       };
33973     }
33974   }
33975 }
33976
33977
33978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33979   void * jresult ;
33980   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33981   Dali::Stage::KeyEventSignalType *result = 0 ;
33982
33983   arg1 = (Dali::Stage *)jarg1;
33984   {
33985     try {
33986       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33987     } catch (std::out_of_range& e) {
33988       {
33989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33990       };
33991     } catch (std::exception& e) {
33992       {
33993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (...) {
33996       {
33997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33998       };
33999     }
34000   }
34001   jresult = (void *)result;
34002   return jresult;
34003 }
34004
34005
34006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34007   void * jresult ;
34008   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34009   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34010
34011   arg1 = (Dali::Stage *)jarg1;
34012   {
34013     try {
34014       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34015     } catch (std::out_of_range& e) {
34016       {
34017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34018       };
34019     } catch (std::exception& e) {
34020       {
34021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (...) {
34024       {
34025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34026       };
34027     }
34028   }
34029   jresult = (void *)result;
34030   return jresult;
34031 }
34032
34033
34034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34035   void * jresult ;
34036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34037   Dali::Stage::TouchSignalType *result = 0 ;
34038
34039   arg1 = (Dali::Stage *)jarg1;
34040   {
34041     try {
34042       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34043     } catch (std::out_of_range& e) {
34044       {
34045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34046       };
34047     } catch (std::exception& e) {
34048       {
34049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34050       };
34051     } catch (...) {
34052       {
34053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34054       };
34055     }
34056   }
34057   jresult = (void *)result;
34058   return jresult;
34059 }
34060
34061
34062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34063   void * jresult ;
34064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34065   Dali::Stage::WheelEventSignalType *result = 0 ;
34066
34067   arg1 = (Dali::Stage *)jarg1;
34068   {
34069     try {
34070       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34071     } catch (std::out_of_range& e) {
34072       {
34073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34074       };
34075     } catch (std::exception& e) {
34076       {
34077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34078       };
34079     } catch (...) {
34080       {
34081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34082       };
34083     }
34084   }
34085   jresult = (void *)result;
34086   return jresult;
34087 }
34088
34089
34090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34091   void * jresult ;
34092   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34093   Dali::Stage::ContextStatusSignal *result = 0 ;
34094
34095   arg1 = (Dali::Stage *)jarg1;
34096   {
34097     try {
34098       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34110       };
34111     }
34112   }
34113   jresult = (void *)result;
34114   return jresult;
34115 }
34116
34117
34118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34119   void * jresult ;
34120   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34121   Dali::Stage::ContextStatusSignal *result = 0 ;
34122
34123   arg1 = (Dali::Stage *)jarg1;
34124   {
34125     try {
34126       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (...) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34138       };
34139     }
34140   }
34141   jresult = (void *)result;
34142   return jresult;
34143 }
34144
34145
34146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34147   void * jresult ;
34148   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34149   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34150
34151   arg1 = (Dali::Stage *)jarg1;
34152   {
34153     try {
34154       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34155     } catch (std::out_of_range& e) {
34156       {
34157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (std::exception& e) {
34160       {
34161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169   jresult = (void *)result;
34170   return jresult;
34171 }
34172
34173
34174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34175   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34176
34177   arg1 = (Dali::RelayoutContainer *)jarg1;
34178   {
34179     try {
34180       delete arg1;
34181     } catch (std::out_of_range& e) {
34182       {
34183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34184       };
34185     } catch (std::exception& e) {
34186       {
34187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34188       };
34189     } catch (...) {
34190       {
34191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34192       };
34193     }
34194   }
34195 }
34196
34197
34198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34199   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34200   Dali::Actor *arg2 = 0 ;
34201   Dali::Vector2 *arg3 = 0 ;
34202
34203   arg1 = (Dali::RelayoutContainer *)jarg1;
34204   arg2 = (Dali::Actor *)jarg2;
34205   if (!arg2) {
34206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34207     return ;
34208   }
34209   arg3 = (Dali::Vector2 *)jarg3;
34210   if (!arg3) {
34211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34212     return ;
34213   }
34214   {
34215     try {
34216       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34217     } catch (std::out_of_range& e) {
34218       {
34219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34220       };
34221     } catch (std::exception& e) {
34222       {
34223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34224       };
34225     } catch (...) {
34226       {
34227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34228       };
34229     }
34230   }
34231 }
34232
34233
34234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34235   void * jresult ;
34236   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34237   Dali::CustomActor result;
34238
34239   arg1 = (Dali::CustomActorImpl *)jarg1;
34240   {
34241     try {
34242       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34243     } catch (std::out_of_range& e) {
34244       {
34245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34246       };
34247     } catch (std::exception& e) {
34248       {
34249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34250       };
34251     } catch (...) {
34252       {
34253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34254       };
34255     }
34256   }
34257   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34258   return jresult;
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34263   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34264   int arg2 ;
34265
34266   arg1 = (Dali::CustomActorImpl *)jarg1;
34267   arg2 = (int)jarg2;
34268   {
34269     try {
34270       (arg1)->OnStageConnection(arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285 }
34286
34287
34288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34290
34291   arg1 = (Dali::CustomActorImpl *)jarg1;
34292   {
34293     try {
34294       (arg1)->OnStageDisconnection();
34295     } catch (std::out_of_range& e) {
34296       {
34297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34298       };
34299     } catch (std::exception& e) {
34300       {
34301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34302       };
34303     } catch (...) {
34304       {
34305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34306       };
34307     }
34308   }
34309 }
34310
34311
34312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34313   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34314   Dali::Actor *arg2 = 0 ;
34315
34316   arg1 = (Dali::CustomActorImpl *)jarg1;
34317   arg2 = (Dali::Actor *)jarg2;
34318   if (!arg2) {
34319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34320     return ;
34321   }
34322   {
34323     try {
34324       (arg1)->OnChildAdd(*arg2);
34325     } catch (std::out_of_range& e) {
34326       {
34327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34328       };
34329     } catch (std::exception& e) {
34330       {
34331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34332       };
34333     } catch (...) {
34334       {
34335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34336       };
34337     }
34338   }
34339 }
34340
34341
34342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34343   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34344   Dali::Actor *arg2 = 0 ;
34345
34346   arg1 = (Dali::CustomActorImpl *)jarg1;
34347   arg2 = (Dali::Actor *)jarg2;
34348   if (!arg2) {
34349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34350     return ;
34351   }
34352   {
34353     try {
34354       (arg1)->OnChildRemove(*arg2);
34355     } catch (std::out_of_range& e) {
34356       {
34357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34358       };
34359     } catch (std::exception& e) {
34360       {
34361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34362       };
34363     } catch (...) {
34364       {
34365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34366       };
34367     }
34368   }
34369 }
34370
34371
34372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34373   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34374   Dali::Property::Index arg2 ;
34375   Dali::Property::Value arg3 ;
34376   Dali::Property::Value *argp3 ;
34377
34378   arg1 = (Dali::CustomActorImpl *)jarg1;
34379   arg2 = (Dali::Property::Index)jarg2;
34380   argp3 = (Dali::Property::Value *)jarg3;
34381   if (!argp3) {
34382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34383     return ;
34384   }
34385   arg3 = *argp3;
34386   {
34387     try {
34388       (arg1)->OnPropertySet(arg2,arg3);
34389     } catch (std::out_of_range& e) {
34390       {
34391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (std::exception& e) {
34394       {
34395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (...) {
34398       {
34399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34400       };
34401     }
34402   }
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34408   Dali::Vector3 *arg2 = 0 ;
34409
34410   arg1 = (Dali::CustomActorImpl *)jarg1;
34411   arg2 = (Dali::Vector3 *)jarg2;
34412   if (!arg2) {
34413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34414     return ;
34415   }
34416   {
34417     try {
34418       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34419     } catch (std::out_of_range& e) {
34420       {
34421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34422       };
34423     } catch (std::exception& e) {
34424       {
34425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34426       };
34427     } catch (...) {
34428       {
34429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34430       };
34431     }
34432   }
34433 }
34434
34435
34436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34437   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34438   Dali::Animation *arg2 = 0 ;
34439   Dali::Vector3 *arg3 = 0 ;
34440
34441   arg1 = (Dali::CustomActorImpl *)jarg1;
34442   arg2 = (Dali::Animation *)jarg2;
34443   if (!arg2) {
34444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34445     return ;
34446   }
34447   arg3 = (Dali::Vector3 *)jarg3;
34448   if (!arg3) {
34449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34450     return ;
34451   }
34452   {
34453     try {
34454       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34455     } catch (std::out_of_range& e) {
34456       {
34457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34458       };
34459     } catch (std::exception& e) {
34460       {
34461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34462       };
34463     } catch (...) {
34464       {
34465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34466       };
34467     }
34468   }
34469 }
34470
34471
34472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34473   unsigned int jresult ;
34474   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34475   Dali::TouchEvent *arg2 = 0 ;
34476   bool result;
34477
34478   arg1 = (Dali::CustomActorImpl *)jarg1;
34479   arg2 = (Dali::TouchEvent *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34482     return 0;
34483   }
34484   {
34485     try {
34486       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34494       };
34495     } catch (...) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34498       };
34499     }
34500   }
34501   jresult = result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34507   unsigned int jresult ;
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::HoverEvent *arg2 = 0 ;
34510   bool result;
34511
34512   arg1 = (Dali::CustomActorImpl *)jarg1;
34513   arg2 = (Dali::HoverEvent *)jarg2;
34514   if (!arg2) {
34515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34516     return 0;
34517   }
34518   {
34519     try {
34520       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34521     } catch (std::out_of_range& e) {
34522       {
34523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34524       };
34525     } catch (std::exception& e) {
34526       {
34527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34528       };
34529     } catch (...) {
34530       {
34531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34532       };
34533     }
34534   }
34535   jresult = result;
34536   return jresult;
34537 }
34538
34539
34540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34541   unsigned int jresult ;
34542   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34543   Dali::KeyEvent *arg2 = 0 ;
34544   bool result;
34545
34546   arg1 = (Dali::CustomActorImpl *)jarg1;
34547   arg2 = (Dali::KeyEvent *)jarg2;
34548   if (!arg2) {
34549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34550     return 0;
34551   }
34552   {
34553     try {
34554       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34555     } catch (std::out_of_range& e) {
34556       {
34557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34558       };
34559     } catch (std::exception& e) {
34560       {
34561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34562       };
34563     } catch (...) {
34564       {
34565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34566       };
34567     }
34568   }
34569   jresult = result;
34570   return jresult;
34571 }
34572
34573
34574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34575   unsigned int jresult ;
34576   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34577   Dali::WheelEvent *arg2 = 0 ;
34578   bool result;
34579
34580   arg1 = (Dali::CustomActorImpl *)jarg1;
34581   arg2 = (Dali::WheelEvent *)jarg2;
34582   if (!arg2) {
34583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34584     return 0;
34585   }
34586   {
34587     try {
34588       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34589     } catch (std::out_of_range& e) {
34590       {
34591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34592       };
34593     } catch (std::exception& e) {
34594       {
34595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (...) {
34598       {
34599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34600       };
34601     }
34602   }
34603   jresult = result;
34604   return jresult;
34605 }
34606
34607
34608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34609   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34610   Dali::Vector2 *arg2 = 0 ;
34611   Dali::RelayoutContainer *arg3 = 0 ;
34612
34613   arg1 = (Dali::CustomActorImpl *)jarg1;
34614   arg2 = (Dali::Vector2 *)jarg2;
34615   if (!arg2) {
34616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34617     return ;
34618   }
34619   arg3 = (Dali::RelayoutContainer *)jarg3;
34620   if (!arg3) {
34621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34622     return ;
34623   }
34624   {
34625     try {
34626       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34627     } catch (std::out_of_range& e) {
34628       {
34629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34630       };
34631     } catch (std::exception& e) {
34632       {
34633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34634       };
34635     } catch (...) {
34636       {
34637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34638       };
34639     }
34640   }
34641 }
34642
34643
34644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34646   Dali::ResizePolicy::Type arg2 ;
34647   Dali::Dimension::Type arg3 ;
34648
34649   arg1 = (Dali::CustomActorImpl *)jarg1;
34650   arg2 = (Dali::ResizePolicy::Type)jarg2;
34651   arg3 = (Dali::Dimension::Type)jarg3;
34652   {
34653     try {
34654       (arg1)->OnSetResizePolicy(arg2,arg3);
34655     } catch (std::out_of_range& e) {
34656       {
34657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34658       };
34659     } catch (std::exception& e) {
34660       {
34661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34662       };
34663     } catch (...) {
34664       {
34665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34666       };
34667     }
34668   }
34669 }
34670
34671
34672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34673   void * jresult ;
34674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34675   Dali::Vector3 result;
34676
34677   arg1 = (Dali::CustomActorImpl *)jarg1;
34678   {
34679     try {
34680       result = (arg1)->GetNaturalSize();
34681     } catch (std::out_of_range& e) {
34682       {
34683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34684       };
34685     } catch (std::exception& e) {
34686       {
34687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34688       };
34689     } catch (...) {
34690       {
34691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34692       };
34693     }
34694   }
34695   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34696   return jresult;
34697 }
34698
34699
34700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34701   float jresult ;
34702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34703   Dali::Actor *arg2 = 0 ;
34704   Dali::Dimension::Type arg3 ;
34705   float result;
34706
34707   arg1 = (Dali::CustomActorImpl *)jarg1;
34708   arg2 = (Dali::Actor *)jarg2;
34709   if (!arg2) {
34710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34711     return 0;
34712   }
34713   arg3 = (Dali::Dimension::Type)jarg3;
34714   {
34715     try {
34716       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34717     } catch (std::out_of_range& e) {
34718       {
34719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34720       };
34721     } catch (std::exception& e) {
34722       {
34723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34724       };
34725     } catch (...) {
34726       {
34727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34728       };
34729     }
34730   }
34731   jresult = result;
34732   return jresult;
34733 }
34734
34735
34736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34737   float jresult ;
34738   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34739   float arg2 ;
34740   float result;
34741
34742   arg1 = (Dali::CustomActorImpl *)jarg1;
34743   arg2 = (float)jarg2;
34744   {
34745     try {
34746       result = (float)(arg1)->GetHeightForWidth(arg2);
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34758       };
34759     }
34760   }
34761   jresult = result;
34762   return jresult;
34763 }
34764
34765
34766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34767   float jresult ;
34768   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34769   float arg2 ;
34770   float result;
34771
34772   arg1 = (Dali::CustomActorImpl *)jarg1;
34773   arg2 = (float)jarg2;
34774   {
34775     try {
34776       result = (float)(arg1)->GetWidthForHeight(arg2);
34777     } catch (std::out_of_range& e) {
34778       {
34779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34780       };
34781     } catch (std::exception& e) {
34782       {
34783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34784       };
34785     } catch (...) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34788       };
34789     }
34790   }
34791   jresult = result;
34792   return jresult;
34793 }
34794
34795
34796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34797   unsigned int jresult ;
34798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34799   Dali::Dimension::Type arg2 ;
34800   bool result;
34801
34802   arg1 = (Dali::CustomActorImpl *)jarg1;
34803   arg2 = (Dali::Dimension::Type)jarg2;
34804   {
34805     try {
34806       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34818       };
34819     }
34820   }
34821   jresult = result;
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34827   unsigned int jresult ;
34828   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34829   bool result;
34830
34831   arg1 = (Dali::CustomActorImpl *)jarg1;
34832   {
34833     try {
34834       result = (bool)(arg1)->RelayoutDependentOnChildren();
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34842       };
34843     } catch (...) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34846       };
34847     }
34848   }
34849   jresult = result;
34850   return jresult;
34851 }
34852
34853
34854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34856   Dali::Dimension::Type arg2 ;
34857
34858   arg1 = (Dali::CustomActorImpl *)jarg1;
34859   arg2 = (Dali::Dimension::Type)jarg2;
34860   {
34861     try {
34862       (arg1)->OnCalculateRelayoutSize(arg2);
34863     } catch (std::out_of_range& e) {
34864       {
34865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34866       };
34867     } catch (std::exception& e) {
34868       {
34869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34874       };
34875     }
34876   }
34877 }
34878
34879
34880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34881   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34882   float arg2 ;
34883   Dali::Dimension::Type arg3 ;
34884
34885   arg1 = (Dali::CustomActorImpl *)jarg1;
34886   arg2 = (float)jarg2;
34887   arg3 = (Dali::Dimension::Type)jarg3;
34888   {
34889     try {
34890       (arg1)->OnLayoutNegotiated(arg2,arg3);
34891     } catch (std::out_of_range& e) {
34892       {
34893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34894       };
34895     } catch (std::exception& e) {
34896       {
34897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34898       };
34899     } catch (...) {
34900       {
34901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34902       };
34903     }
34904   }
34905 }
34906
34907
34908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34909   unsigned int jresult ;
34910   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34911   bool result;
34912
34913   arg1 = (Dali::CustomActorImpl *)jarg1;
34914   {
34915     try {
34916       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34917     } catch (std::out_of_range& e) {
34918       {
34919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34920       };
34921     } catch (std::exception& e) {
34922       {
34923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34924       };
34925     } catch (...) {
34926       {
34927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34928       };
34929     }
34930   }
34931   jresult = result;
34932   return jresult;
34933 }
34934
34935
34936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34937   unsigned int jresult ;
34938   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34939   bool result;
34940
34941   arg1 = (Dali::CustomActorImpl *)jarg1;
34942   {
34943     try {
34944       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34945     } catch (std::out_of_range& e) {
34946       {
34947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34948       };
34949     } catch (std::exception& e) {
34950       {
34951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34952       };
34953     } catch (...) {
34954       {
34955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34956       };
34957     }
34958   }
34959   jresult = result;
34960   return jresult;
34961 }
34962
34963
34964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34965   unsigned int jresult ;
34966   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34967   bool result;
34968
34969   arg1 = (Dali::CustomActorImpl *)jarg1;
34970   {
34971     try {
34972       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34973     } catch (std::out_of_range& e) {
34974       {
34975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34976       };
34977     } catch (std::exception& e) {
34978       {
34979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34980       };
34981     } catch (...) {
34982       {
34983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34984       };
34985     }
34986   }
34987   jresult = result;
34988   return jresult;
34989 }
34990
34991
34992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34993   unsigned int jresult ;
34994   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34995   bool result;
34996
34997   arg1 = (Dali::CustomActorImpl *)jarg1;
34998   {
34999     try {
35000       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
35001     } catch (std::out_of_range& e) {
35002       {
35003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35004       };
35005     } catch (std::exception& e) {
35006       {
35007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35008       };
35009     } catch (...) {
35010       {
35011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35012       };
35013     }
35014   }
35015   jresult = result;
35016   return jresult;
35017 }
35018
35019
35020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35021   void * jresult ;
35022   Dali::CustomActor *result = 0 ;
35023
35024   {
35025     try {
35026       result = (Dali::CustomActor *)new Dali::CustomActor();
35027     } catch (std::out_of_range& e) {
35028       {
35029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (std::exception& e) {
35032       {
35033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041   jresult = (void *)result;
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35047   void * jresult ;
35048   Dali::BaseHandle arg1 ;
35049   Dali::BaseHandle *argp1 ;
35050   Dali::CustomActor result;
35051
35052   argp1 = (Dali::BaseHandle *)jarg1;
35053   if (!argp1) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35055     return 0;
35056   }
35057   arg1 = *argp1;
35058   {
35059     try {
35060       result = Dali::CustomActor::DownCast(arg1);
35061     } catch (std::out_of_range& e) {
35062       {
35063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35064       };
35065     } catch (std::exception& e) {
35066       {
35067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35068       };
35069     } catch (...) {
35070       {
35071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35072       };
35073     }
35074   }
35075   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35076   return jresult;
35077 }
35078
35079
35080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35081   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35082
35083   arg1 = (Dali::CustomActor *)jarg1;
35084   {
35085     try {
35086       delete arg1;
35087     } catch (std::out_of_range& e) {
35088       {
35089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35090       };
35091     } catch (std::exception& e) {
35092       {
35093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (...) {
35096       {
35097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35098       };
35099     }
35100   }
35101 }
35102
35103
35104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35105   void * jresult ;
35106   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35107   Dali::CustomActorImpl *result = 0 ;
35108
35109   arg1 = (Dali::CustomActor *)jarg1;
35110   {
35111     try {
35112       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35113     } catch (std::out_of_range& e) {
35114       {
35115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (std::exception& e) {
35118       {
35119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35120       };
35121     } catch (...) {
35122       {
35123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35124       };
35125     }
35126   }
35127   jresult = (void *)result;
35128   return jresult;
35129 }
35130
35131
35132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35133   void * jresult ;
35134   Dali::CustomActorImpl *arg1 = 0 ;
35135   Dali::CustomActor *result = 0 ;
35136
35137   arg1 = (Dali::CustomActorImpl *)jarg1;
35138   if (!arg1) {
35139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35140     return 0;
35141   }
35142   {
35143     try {
35144       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35145     } catch (std::out_of_range& e) {
35146       {
35147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35148       };
35149     } catch (std::exception& e) {
35150       {
35151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35152       };
35153     } catch (...) {
35154       {
35155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35156       };
35157     }
35158   }
35159   jresult = (void *)result;
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35165   void * jresult ;
35166   Dali::CustomActor *arg1 = 0 ;
35167   Dali::CustomActor *result = 0 ;
35168
35169   arg1 = (Dali::CustomActor *)jarg1;
35170   if (!arg1) {
35171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35172     return 0;
35173   }
35174   {
35175     try {
35176       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35177     } catch (std::out_of_range& e) {
35178       {
35179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35180       };
35181     } catch (std::exception& e) {
35182       {
35183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35184       };
35185     } catch (...) {
35186       {
35187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35188       };
35189     }
35190   }
35191   jresult = (void *)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35197   void * jresult ;
35198   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35199   Dali::CustomActor *arg2 = 0 ;
35200   Dali::CustomActor *result = 0 ;
35201
35202   arg1 = (Dali::CustomActor *)jarg1;
35203   arg2 = (Dali::CustomActor *)jarg2;
35204   if (!arg2) {
35205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35206     return 0;
35207   }
35208   {
35209     try {
35210       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35211     } catch (std::out_of_range& e) {
35212       {
35213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35214       };
35215     } catch (std::exception& e) {
35216       {
35217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35222       };
35223     }
35224   }
35225   jresult = (void *)result;
35226   return jresult;
35227 }
35228
35229
35230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35231   int jresult ;
35232   int result;
35233
35234   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35235   jresult = (int)result;
35236   return jresult;
35237 }
35238
35239
35240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35241   int jresult ;
35242   int result;
35243
35244   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35245   jresult = (int)result;
35246   return jresult;
35247 }
35248
35249
35250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35251   int jresult ;
35252   int result;
35253
35254   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35255   jresult = (int)result;
35256   return jresult;
35257 }
35258
35259
35260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35261   int jresult ;
35262   int result;
35263
35264   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35265   jresult = (int)result;
35266   return jresult;
35267 }
35268
35269
35270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35271   int jresult ;
35272   int result;
35273
35274   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35275   jresult = (int)result;
35276   return jresult;
35277 }
35278
35279
35280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35281   int jresult ;
35282   int result;
35283
35284   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35285   jresult = (int)result;
35286   return jresult;
35287 }
35288
35289
35290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35291   int jresult ;
35292   int result;
35293
35294   result = (int)Dali::PanGestureDetector::Property::PANNING;
35295   jresult = (int)result;
35296   return jresult;
35297 }
35298
35299
35300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35301   void * jresult ;
35302   Dali::PanGestureDetector::Property *result = 0 ;
35303
35304   {
35305     try {
35306       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35307     } catch (std::out_of_range& e) {
35308       {
35309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (std::exception& e) {
35312       {
35313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35314       };
35315     } catch (...) {
35316       {
35317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35318       };
35319     }
35320   }
35321   jresult = (void *)result;
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35327   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35328
35329   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35330   {
35331     try {
35332       delete arg1;
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (...) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35344       };
35345     }
35346   }
35347 }
35348
35349
35350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35351   void * jresult ;
35352   Dali::Radian *result = 0 ;
35353
35354   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35355   jresult = (void *)result;
35356   return jresult;
35357 }
35358
35359
35360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35361   void * jresult ;
35362   Dali::Radian *result = 0 ;
35363
35364   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35365   jresult = (void *)result;
35366   return jresult;
35367 }
35368
35369
35370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35371   void * jresult ;
35372   Dali::Radian *result = 0 ;
35373
35374   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35375   jresult = (void *)result;
35376   return jresult;
35377 }
35378
35379
35380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35381   void * jresult ;
35382   Dali::Radian *result = 0 ;
35383
35384   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35385   jresult = (void *)result;
35386   return jresult;
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35391   void * jresult ;
35392   Dali::Radian *result = 0 ;
35393
35394   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35395   jresult = (void *)result;
35396   return jresult;
35397 }
35398
35399
35400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35401   void * jresult ;
35402   Dali::Radian *result = 0 ;
35403
35404   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35405   jresult = (void *)result;
35406   return jresult;
35407 }
35408
35409
35410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35411   void * jresult ;
35412   Dali::Radian *result = 0 ;
35413
35414   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35415   jresult = (void *)result;
35416   return jresult;
35417 }
35418
35419
35420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35421   void * jresult ;
35422   Dali::PanGestureDetector *result = 0 ;
35423
35424   {
35425     try {
35426       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35427     } catch (std::out_of_range& e) {
35428       {
35429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35430       };
35431     } catch (std::exception& e) {
35432       {
35433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (...) {
35436       {
35437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35438       };
35439     }
35440   }
35441   jresult = (void *)result;
35442   return jresult;
35443 }
35444
35445
35446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35447   void * jresult ;
35448   Dali::PanGestureDetector result;
35449
35450   {
35451     try {
35452       result = Dali::PanGestureDetector::New();
35453     } catch (std::out_of_range& e) {
35454       {
35455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35456       };
35457     } catch (std::exception& e) {
35458       {
35459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35460       };
35461     } catch (...) {
35462       {
35463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35464       };
35465     }
35466   }
35467   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35468   return jresult;
35469 }
35470
35471
35472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35473   void * jresult ;
35474   Dali::BaseHandle arg1 ;
35475   Dali::BaseHandle *argp1 ;
35476   Dali::PanGestureDetector result;
35477
35478   argp1 = (Dali::BaseHandle *)jarg1;
35479   if (!argp1) {
35480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35481     return 0;
35482   }
35483   arg1 = *argp1;
35484   {
35485     try {
35486       result = Dali::PanGestureDetector::DownCast(arg1);
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35507   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35508
35509   arg1 = (Dali::PanGestureDetector *)jarg1;
35510   {
35511     try {
35512       delete arg1;
35513     } catch (std::out_of_range& e) {
35514       {
35515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35516       };
35517     } catch (std::exception& e) {
35518       {
35519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35520       };
35521     } catch (...) {
35522       {
35523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35524       };
35525     }
35526   }
35527 }
35528
35529
35530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35531   void * jresult ;
35532   Dali::PanGestureDetector *arg1 = 0 ;
35533   Dali::PanGestureDetector *result = 0 ;
35534
35535   arg1 = (Dali::PanGestureDetector *)jarg1;
35536   if (!arg1) {
35537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35538     return 0;
35539   }
35540   {
35541     try {
35542       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35554       };
35555     }
35556   }
35557   jresult = (void *)result;
35558   return jresult;
35559 }
35560
35561
35562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35563   void * jresult ;
35564   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35565   Dali::PanGestureDetector *arg2 = 0 ;
35566   Dali::PanGestureDetector *result = 0 ;
35567
35568   arg1 = (Dali::PanGestureDetector *)jarg1;
35569   arg2 = (Dali::PanGestureDetector *)jarg2;
35570   if (!arg2) {
35571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35572     return 0;
35573   }
35574   {
35575     try {
35576       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35577     } catch (std::out_of_range& e) {
35578       {
35579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35580       };
35581     } catch (std::exception& e) {
35582       {
35583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35584       };
35585     } catch (...) {
35586       {
35587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35588       };
35589     }
35590   }
35591   jresult = (void *)result;
35592   return jresult;
35593 }
35594
35595
35596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35597   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35598   unsigned int arg2 ;
35599
35600   arg1 = (Dali::PanGestureDetector *)jarg1;
35601   arg2 = (unsigned int)jarg2;
35602   {
35603     try {
35604       (arg1)->SetMinimumTouchesRequired(arg2);
35605     } catch (std::out_of_range& e) {
35606       {
35607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (std::exception& e) {
35610       {
35611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35616       };
35617     }
35618   }
35619 }
35620
35621
35622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35624   unsigned int arg2 ;
35625
35626   arg1 = (Dali::PanGestureDetector *)jarg1;
35627   arg2 = (unsigned int)jarg2;
35628   {
35629     try {
35630       (arg1)->SetMaximumTouchesRequired(arg2);
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35638       };
35639     } catch (...) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35642       };
35643     }
35644   }
35645 }
35646
35647
35648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35649   unsigned int jresult ;
35650   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35651   unsigned int result;
35652
35653   arg1 = (Dali::PanGestureDetector *)jarg1;
35654   {
35655     try {
35656       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (...) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35668       };
35669     }
35670   }
35671   jresult = result;
35672   return jresult;
35673 }
35674
35675
35676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35677   unsigned int jresult ;
35678   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35679   unsigned int result;
35680
35681   arg1 = (Dali::PanGestureDetector *)jarg1;
35682   {
35683     try {
35684       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35685     } catch (std::out_of_range& e) {
35686       {
35687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35688       };
35689     } catch (std::exception& e) {
35690       {
35691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (...) {
35694       {
35695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35696       };
35697     }
35698   }
35699   jresult = result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35705   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35706   Dali::Radian arg2 ;
35707   Dali::Radian arg3 ;
35708   Dali::Radian *argp2 ;
35709   Dali::Radian *argp3 ;
35710
35711   arg1 = (Dali::PanGestureDetector *)jarg1;
35712   argp2 = (Dali::Radian *)jarg2;
35713   if (!argp2) {
35714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35715     return ;
35716   }
35717   arg2 = *argp2;
35718   argp3 = (Dali::Radian *)jarg3;
35719   if (!argp3) {
35720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35721     return ;
35722   }
35723   arg3 = *argp3;
35724   {
35725     try {
35726       (arg1)->AddAngle(arg2,arg3);
35727     } catch (std::out_of_range& e) {
35728       {
35729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (std::exception& e) {
35732       {
35733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35738       };
35739     }
35740   }
35741 }
35742
35743
35744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35745   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35746   Dali::Radian arg2 ;
35747   Dali::Radian *argp2 ;
35748
35749   arg1 = (Dali::PanGestureDetector *)jarg1;
35750   argp2 = (Dali::Radian *)jarg2;
35751   if (!argp2) {
35752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35753     return ;
35754   }
35755   arg2 = *argp2;
35756   {
35757     try {
35758       (arg1)->AddAngle(arg2);
35759     } catch (std::out_of_range& e) {
35760       {
35761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35762       };
35763     } catch (std::exception& e) {
35764       {
35765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35766       };
35767     } catch (...) {
35768       {
35769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35770       };
35771     }
35772   }
35773 }
35774
35775
35776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35777   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35778   Dali::Radian arg2 ;
35779   Dali::Radian arg3 ;
35780   Dali::Radian *argp2 ;
35781   Dali::Radian *argp3 ;
35782
35783   arg1 = (Dali::PanGestureDetector *)jarg1;
35784   argp2 = (Dali::Radian *)jarg2;
35785   if (!argp2) {
35786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35787     return ;
35788   }
35789   arg2 = *argp2;
35790   argp3 = (Dali::Radian *)jarg3;
35791   if (!argp3) {
35792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35793     return ;
35794   }
35795   arg3 = *argp3;
35796   {
35797     try {
35798       (arg1)->AddDirection(arg2,arg3);
35799     } catch (std::out_of_range& e) {
35800       {
35801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (std::exception& e) {
35804       {
35805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35810       };
35811     }
35812   }
35813 }
35814
35815
35816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35817   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35818   Dali::Radian arg2 ;
35819   Dali::Radian *argp2 ;
35820
35821   arg1 = (Dali::PanGestureDetector *)jarg1;
35822   argp2 = (Dali::Radian *)jarg2;
35823   if (!argp2) {
35824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35825     return ;
35826   }
35827   arg2 = *argp2;
35828   {
35829     try {
35830       (arg1)->AddDirection(arg2);
35831     } catch (std::out_of_range& e) {
35832       {
35833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35834       };
35835     } catch (std::exception& e) {
35836       {
35837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35842       };
35843     }
35844   }
35845 }
35846
35847
35848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35849   unsigned long jresult ;
35850   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35851   size_t result;
35852
35853   arg1 = (Dali::PanGestureDetector *)jarg1;
35854   {
35855     try {
35856       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35857     } catch (std::out_of_range& e) {
35858       {
35859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35860       };
35861     } catch (std::exception& e) {
35862       {
35863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35868       };
35869     }
35870   }
35871   jresult = (unsigned long)result;
35872   return jresult;
35873 }
35874
35875
35876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35877   void * jresult ;
35878   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35879   size_t arg2 ;
35880   Dali::PanGestureDetector::AngleThresholdPair result;
35881
35882   arg1 = (Dali::PanGestureDetector *)jarg1;
35883   arg2 = (size_t)jarg2;
35884   {
35885     try {
35886       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35887     } catch (std::out_of_range& e) {
35888       {
35889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35890       };
35891     } catch (std::exception& e) {
35892       {
35893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35898       };
35899     }
35900   }
35901   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35902   return jresult;
35903 }
35904
35905
35906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35907   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35908
35909   arg1 = (Dali::PanGestureDetector *)jarg1;
35910   {
35911     try {
35912       (arg1)->ClearAngles();
35913     } catch (std::out_of_range& e) {
35914       {
35915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35916       };
35917     } catch (std::exception& e) {
35918       {
35919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (...) {
35922       {
35923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35924       };
35925     }
35926   }
35927 }
35928
35929
35930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35931   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35932   Dali::Radian arg2 ;
35933   Dali::Radian *argp2 ;
35934
35935   arg1 = (Dali::PanGestureDetector *)jarg1;
35936   argp2 = (Dali::Radian *)jarg2;
35937   if (!argp2) {
35938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35939     return ;
35940   }
35941   arg2 = *argp2;
35942   {
35943     try {
35944       (arg1)->RemoveAngle(arg2);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (...) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35956       };
35957     }
35958   }
35959 }
35960
35961
35962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35963   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35964   Dali::Radian arg2 ;
35965   Dali::Radian *argp2 ;
35966
35967   arg1 = (Dali::PanGestureDetector *)jarg1;
35968   argp2 = (Dali::Radian *)jarg2;
35969   if (!argp2) {
35970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35971     return ;
35972   }
35973   arg2 = *argp2;
35974   {
35975     try {
35976       (arg1)->RemoveDirection(arg2);
35977     } catch (std::out_of_range& e) {
35978       {
35979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35980       };
35981     } catch (std::exception& e) {
35982       {
35983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35984       };
35985     } catch (...) {
35986       {
35987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35988       };
35989     }
35990   }
35991 }
35992
35993
35994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35995   void * jresult ;
35996   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35997   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35998
35999   arg1 = (Dali::PanGestureDetector *)jarg1;
36000   {
36001     try {
36002       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36003     } catch (std::out_of_range& e) {
36004       {
36005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36006       };
36007     } catch (std::exception& e) {
36008       {
36009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36010       };
36011     } catch (...) {
36012       {
36013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36014       };
36015     }
36016   }
36017   jresult = (void *)result;
36018   return jresult;
36019 }
36020
36021
36022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36023   Dali::PanGesture *arg1 = 0 ;
36024
36025   arg1 = (Dali::PanGesture *)jarg1;
36026   if (!arg1) {
36027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36028     return ;
36029   }
36030   {
36031     try {
36032       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36033     } catch (std::out_of_range& e) {
36034       {
36035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36036       };
36037     } catch (std::exception& e) {
36038       {
36039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36044       };
36045     }
36046   }
36047 }
36048
36049
36050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36051   void * jresult ;
36052   Dali::PanGesture *result = 0 ;
36053
36054   {
36055     try {
36056       result = (Dali::PanGesture *)new Dali::PanGesture();
36057     } catch (std::out_of_range& e) {
36058       {
36059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (std::exception& e) {
36062       {
36063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071   jresult = (void *)result;
36072   return jresult;
36073 }
36074
36075
36076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36077   void * jresult ;
36078   Dali::Gesture::State arg1 ;
36079   Dali::PanGesture *result = 0 ;
36080
36081   arg1 = (Dali::Gesture::State)jarg1;
36082   {
36083     try {
36084       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36085     } catch (std::out_of_range& e) {
36086       {
36087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36088       };
36089     } catch (std::exception& e) {
36090       {
36091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36096       };
36097     }
36098   }
36099   jresult = (void *)result;
36100   return jresult;
36101 }
36102
36103
36104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36105   void * jresult ;
36106   Dali::PanGesture *arg1 = 0 ;
36107   Dali::PanGesture *result = 0 ;
36108
36109   arg1 = (Dali::PanGesture *)jarg1;
36110   if (!arg1) {
36111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36112     return 0;
36113   }
36114   {
36115     try {
36116       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (...) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36128       };
36129     }
36130   }
36131   jresult = (void *)result;
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36137   void * jresult ;
36138   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36139   Dali::PanGesture *arg2 = 0 ;
36140   Dali::PanGesture *result = 0 ;
36141
36142   arg1 = (Dali::PanGesture *)jarg1;
36143   arg2 = (Dali::PanGesture *)jarg2;
36144   if (!arg2) {
36145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36146     return 0;
36147   }
36148   {
36149     try {
36150       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36151     } catch (std::out_of_range& e) {
36152       {
36153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (std::exception& e) {
36156       {
36157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36158       };
36159     } catch (...) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36162       };
36163     }
36164   }
36165   jresult = (void *)result;
36166   return jresult;
36167 }
36168
36169
36170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36171   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36172
36173   arg1 = (Dali::PanGesture *)jarg1;
36174   {
36175     try {
36176       delete arg1;
36177     } catch (std::out_of_range& e) {
36178       {
36179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36180       };
36181     } catch (std::exception& e) {
36182       {
36183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36184       };
36185     } catch (...) {
36186       {
36187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36188       };
36189     }
36190   }
36191 }
36192
36193
36194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36197
36198   arg1 = (Dali::PanGesture *)jarg1;
36199   arg2 = (Dali::Vector2 *)jarg2;
36200   if (arg1) (arg1)->velocity = *arg2;
36201 }
36202
36203
36204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36205   void * jresult ;
36206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36207   Dali::Vector2 *result = 0 ;
36208
36209   arg1 = (Dali::PanGesture *)jarg1;
36210   result = (Dali::Vector2 *)& ((arg1)->velocity);
36211   jresult = (void *)result;
36212   return jresult;
36213 }
36214
36215
36216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36219
36220   arg1 = (Dali::PanGesture *)jarg1;
36221   arg2 = (Dali::Vector2 *)jarg2;
36222   if (arg1) (arg1)->displacement = *arg2;
36223 }
36224
36225
36226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36227   void * jresult ;
36228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36229   Dali::Vector2 *result = 0 ;
36230
36231   arg1 = (Dali::PanGesture *)jarg1;
36232   result = (Dali::Vector2 *)& ((arg1)->displacement);
36233   jresult = (void *)result;
36234   return jresult;
36235 }
36236
36237
36238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36240   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36241
36242   arg1 = (Dali::PanGesture *)jarg1;
36243   arg2 = (Dali::Vector2 *)jarg2;
36244   if (arg1) (arg1)->position = *arg2;
36245 }
36246
36247
36248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36249   void * jresult ;
36250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36251   Dali::Vector2 *result = 0 ;
36252
36253   arg1 = (Dali::PanGesture *)jarg1;
36254   result = (Dali::Vector2 *)& ((arg1)->position);
36255   jresult = (void *)result;
36256   return jresult;
36257 }
36258
36259
36260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36262   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36263
36264   arg1 = (Dali::PanGesture *)jarg1;
36265   arg2 = (Dali::Vector2 *)jarg2;
36266   if (arg1) (arg1)->screenVelocity = *arg2;
36267 }
36268
36269
36270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36271   void * jresult ;
36272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36273   Dali::Vector2 *result = 0 ;
36274
36275   arg1 = (Dali::PanGesture *)jarg1;
36276   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36277   jresult = (void *)result;
36278   return jresult;
36279 }
36280
36281
36282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36284   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36285
36286   arg1 = (Dali::PanGesture *)jarg1;
36287   arg2 = (Dali::Vector2 *)jarg2;
36288   if (arg1) (arg1)->screenDisplacement = *arg2;
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36293   void * jresult ;
36294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36295   Dali::Vector2 *result = 0 ;
36296
36297   arg1 = (Dali::PanGesture *)jarg1;
36298   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36299   jresult = (void *)result;
36300   return jresult;
36301 }
36302
36303
36304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   arg2 = (Dali::Vector2 *)jarg2;
36310   if (arg1) (arg1)->screenPosition = *arg2;
36311 }
36312
36313
36314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36315   void * jresult ;
36316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36317   Dali::Vector2 *result = 0 ;
36318
36319   arg1 = (Dali::PanGesture *)jarg1;
36320   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36321   jresult = (void *)result;
36322   return jresult;
36323 }
36324
36325
36326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36327   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36328   unsigned int arg2 ;
36329
36330   arg1 = (Dali::PanGesture *)jarg1;
36331   arg2 = (unsigned int)jarg2;
36332   if (arg1) (arg1)->numberOfTouches = arg2;
36333 }
36334
36335
36336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36337   unsigned int jresult ;
36338   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36339   unsigned int result;
36340
36341   arg1 = (Dali::PanGesture *)jarg1;
36342   result = (unsigned int) ((arg1)->numberOfTouches);
36343   jresult = result;
36344   return jresult;
36345 }
36346
36347
36348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36349   float jresult ;
36350   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36351   float result;
36352
36353   arg1 = (Dali::PanGesture *)jarg1;
36354   {
36355     try {
36356       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36377   float jresult ;
36378   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36379   float result;
36380
36381   arg1 = (Dali::PanGesture *)jarg1;
36382   {
36383     try {
36384       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (...) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36396       };
36397     }
36398   }
36399   jresult = result;
36400   return jresult;
36401 }
36402
36403
36404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36405   float jresult ;
36406   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36407   float result;
36408
36409   arg1 = (Dali::PanGesture *)jarg1;
36410   {
36411     try {
36412       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36413     } catch (std::out_of_range& e) {
36414       {
36415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (std::exception& e) {
36418       {
36419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36420       };
36421     } catch (...) {
36422       {
36423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36424       };
36425     }
36426   }
36427   jresult = result;
36428   return jresult;
36429 }
36430
36431
36432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36433   float jresult ;
36434   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36435   float result;
36436
36437   arg1 = (Dali::PanGesture *)jarg1;
36438   {
36439     try {
36440       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36441     } catch (std::out_of_range& e) {
36442       {
36443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36444       };
36445     } catch (std::exception& e) {
36446       {
36447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36448       };
36449     } catch (...) {
36450       {
36451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36452       };
36453     }
36454   }
36455   jresult = result;
36456   return jresult;
36457 }
36458
36459
36460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36461   void * jresult ;
36462   Dali::PinchGestureDetector *result = 0 ;
36463
36464   {
36465     try {
36466       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36467     } catch (std::out_of_range& e) {
36468       {
36469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (std::exception& e) {
36472       {
36473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36474       };
36475     } catch (...) {
36476       {
36477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36478       };
36479     }
36480   }
36481   jresult = (void *)result;
36482   return jresult;
36483 }
36484
36485
36486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36487   void * jresult ;
36488   Dali::PinchGestureDetector result;
36489
36490   {
36491     try {
36492       result = Dali::PinchGestureDetector::New();
36493     } catch (std::out_of_range& e) {
36494       {
36495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (std::exception& e) {
36498       {
36499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (...) {
36502       {
36503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36504       };
36505     }
36506   }
36507   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36513   void * jresult ;
36514   Dali::BaseHandle arg1 ;
36515   Dali::BaseHandle *argp1 ;
36516   Dali::PinchGestureDetector result;
36517
36518   argp1 = (Dali::BaseHandle *)jarg1;
36519   if (!argp1) {
36520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36521     return 0;
36522   }
36523   arg1 = *argp1;
36524   {
36525     try {
36526       result = Dali::PinchGestureDetector::DownCast(arg1);
36527     } catch (std::out_of_range& e) {
36528       {
36529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (std::exception& e) {
36532       {
36533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36534       };
36535     } catch (...) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36538       };
36539     }
36540   }
36541   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36542   return jresult;
36543 }
36544
36545
36546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36547   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36548
36549   arg1 = (Dali::PinchGestureDetector *)jarg1;
36550   {
36551     try {
36552       delete arg1;
36553     } catch (std::out_of_range& e) {
36554       {
36555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36556       };
36557     } catch (std::exception& e) {
36558       {
36559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36560       };
36561     } catch (...) {
36562       {
36563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36564       };
36565     }
36566   }
36567 }
36568
36569
36570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36571   void * jresult ;
36572   Dali::PinchGestureDetector *arg1 = 0 ;
36573   Dali::PinchGestureDetector *result = 0 ;
36574
36575   arg1 = (Dali::PinchGestureDetector *)jarg1;
36576   if (!arg1) {
36577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36578     return 0;
36579   }
36580   {
36581     try {
36582       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36583     } catch (std::out_of_range& e) {
36584       {
36585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36586       };
36587     } catch (std::exception& e) {
36588       {
36589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36590       };
36591     } catch (...) {
36592       {
36593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36594       };
36595     }
36596   }
36597   jresult = (void *)result;
36598   return jresult;
36599 }
36600
36601
36602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36603   void * jresult ;
36604   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36605   Dali::PinchGestureDetector *arg2 = 0 ;
36606   Dali::PinchGestureDetector *result = 0 ;
36607
36608   arg1 = (Dali::PinchGestureDetector *)jarg1;
36609   arg2 = (Dali::PinchGestureDetector *)jarg2;
36610   if (!arg2) {
36611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36612     return 0;
36613   }
36614   {
36615     try {
36616       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36617     } catch (std::out_of_range& e) {
36618       {
36619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36620       };
36621     } catch (std::exception& e) {
36622       {
36623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36624       };
36625     } catch (...) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36628       };
36629     }
36630   }
36631   jresult = (void *)result;
36632   return jresult;
36633 }
36634
36635
36636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36637   void * jresult ;
36638   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36639   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36640
36641   arg1 = (Dali::PinchGestureDetector *)jarg1;
36642   {
36643     try {
36644       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36645     } catch (std::out_of_range& e) {
36646       {
36647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36648       };
36649     } catch (std::exception& e) {
36650       {
36651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36652       };
36653     } catch (...) {
36654       {
36655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36656       };
36657     }
36658   }
36659   jresult = (void *)result;
36660   return jresult;
36661 }
36662
36663
36664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36665   void * jresult ;
36666   Dali::Gesture::State arg1 ;
36667   Dali::PinchGesture *result = 0 ;
36668
36669   arg1 = (Dali::Gesture::State)jarg1;
36670   {
36671     try {
36672       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36673     } catch (std::out_of_range& e) {
36674       {
36675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36676       };
36677     } catch (std::exception& e) {
36678       {
36679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36680       };
36681     } catch (...) {
36682       {
36683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36684       };
36685     }
36686   }
36687   jresult = (void *)result;
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36693   void * jresult ;
36694   Dali::PinchGesture *arg1 = 0 ;
36695   Dali::PinchGesture *result = 0 ;
36696
36697   arg1 = (Dali::PinchGesture *)jarg1;
36698   if (!arg1) {
36699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36700     return 0;
36701   }
36702   {
36703     try {
36704       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36705     } catch (std::out_of_range& e) {
36706       {
36707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (std::exception& e) {
36710       {
36711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719   jresult = (void *)result;
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36725   void * jresult ;
36726   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36727   Dali::PinchGesture *arg2 = 0 ;
36728   Dali::PinchGesture *result = 0 ;
36729
36730   arg1 = (Dali::PinchGesture *)jarg1;
36731   arg2 = (Dali::PinchGesture *)jarg2;
36732   if (!arg2) {
36733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36734     return 0;
36735   }
36736   {
36737     try {
36738       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36739     } catch (std::out_of_range& e) {
36740       {
36741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36742       };
36743     } catch (std::exception& e) {
36744       {
36745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36746       };
36747     } catch (...) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36750       };
36751     }
36752   }
36753   jresult = (void *)result;
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36759   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36760
36761   arg1 = (Dali::PinchGesture *)jarg1;
36762   {
36763     try {
36764       delete arg1;
36765     } catch (std::out_of_range& e) {
36766       {
36767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36768       };
36769     } catch (std::exception& e) {
36770       {
36771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36772       };
36773     } catch (...) {
36774       {
36775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36776       };
36777     }
36778   }
36779 }
36780
36781
36782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36783   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36784   float arg2 ;
36785
36786   arg1 = (Dali::PinchGesture *)jarg1;
36787   arg2 = (float)jarg2;
36788   if (arg1) (arg1)->scale = arg2;
36789 }
36790
36791
36792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36793   float jresult ;
36794   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36795   float result;
36796
36797   arg1 = (Dali::PinchGesture *)jarg1;
36798   result = (float) ((arg1)->scale);
36799   jresult = result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36805   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36806   float arg2 ;
36807
36808   arg1 = (Dali::PinchGesture *)jarg1;
36809   arg2 = (float)jarg2;
36810   if (arg1) (arg1)->speed = arg2;
36811 }
36812
36813
36814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36815   float jresult ;
36816   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36817   float result;
36818
36819   arg1 = (Dali::PinchGesture *)jarg1;
36820   result = (float) ((arg1)->speed);
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36827   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36828   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36829
36830   arg1 = (Dali::PinchGesture *)jarg1;
36831   arg2 = (Dali::Vector2 *)jarg2;
36832   if (arg1) (arg1)->screenCenterPoint = *arg2;
36833 }
36834
36835
36836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36837   void * jresult ;
36838   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36839   Dali::Vector2 *result = 0 ;
36840
36841   arg1 = (Dali::PinchGesture *)jarg1;
36842   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36843   jresult = (void *)result;
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36849   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36850   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36851
36852   arg1 = (Dali::PinchGesture *)jarg1;
36853   arg2 = (Dali::Vector2 *)jarg2;
36854   if (arg1) (arg1)->localCenterPoint = *arg2;
36855 }
36856
36857
36858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36859   void * jresult ;
36860   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36861   Dali::Vector2 *result = 0 ;
36862
36863   arg1 = (Dali::PinchGesture *)jarg1;
36864   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36865   jresult = (void *)result;
36866   return jresult;
36867 }
36868
36869
36870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36871   void * jresult ;
36872   Dali::TapGestureDetector *result = 0 ;
36873
36874   {
36875     try {
36876       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (...) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36888       };
36889     }
36890   }
36891   jresult = (void *)result;
36892   return jresult;
36893 }
36894
36895
36896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36897   void * jresult ;
36898   Dali::TapGestureDetector result;
36899
36900   {
36901     try {
36902       result = Dali::TapGestureDetector::New();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (...) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36914       };
36915     }
36916   }
36917   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36918   return jresult;
36919 }
36920
36921
36922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36923   void * jresult ;
36924   unsigned int arg1 ;
36925   Dali::TapGestureDetector result;
36926
36927   arg1 = (unsigned int)jarg1;
36928   {
36929     try {
36930       result = Dali::TapGestureDetector::New(arg1);
36931     } catch (std::out_of_range& e) {
36932       {
36933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36934       };
36935     } catch (std::exception& e) {
36936       {
36937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36938       };
36939     } catch (...) {
36940       {
36941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36942       };
36943     }
36944   }
36945   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36946   return jresult;
36947 }
36948
36949
36950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36951   void * jresult ;
36952   Dali::BaseHandle arg1 ;
36953   Dali::BaseHandle *argp1 ;
36954   Dali::TapGestureDetector result;
36955
36956   argp1 = (Dali::BaseHandle *)jarg1;
36957   if (!argp1) {
36958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36959     return 0;
36960   }
36961   arg1 = *argp1;
36962   {
36963     try {
36964       result = Dali::TapGestureDetector::DownCast(arg1);
36965     } catch (std::out_of_range& e) {
36966       {
36967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36968       };
36969     } catch (std::exception& e) {
36970       {
36971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (...) {
36974       {
36975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36976       };
36977     }
36978   }
36979   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36985   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36986
36987   arg1 = (Dali::TapGestureDetector *)jarg1;
36988   {
36989     try {
36990       delete arg1;
36991     } catch (std::out_of_range& e) {
36992       {
36993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36994       };
36995     } catch (std::exception& e) {
36996       {
36997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36998       };
36999     } catch (...) {
37000       {
37001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37002       };
37003     }
37004   }
37005 }
37006
37007
37008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37009   void * jresult ;
37010   Dali::TapGestureDetector *arg1 = 0 ;
37011   Dali::TapGestureDetector *result = 0 ;
37012
37013   arg1 = (Dali::TapGestureDetector *)jarg1;
37014   if (!arg1) {
37015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37016     return 0;
37017   }
37018   {
37019     try {
37020       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37021     } catch (std::out_of_range& e) {
37022       {
37023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37024       };
37025     } catch (std::exception& e) {
37026       {
37027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37028       };
37029     } catch (...) {
37030       {
37031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37032       };
37033     }
37034   }
37035   jresult = (void *)result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37041   void * jresult ;
37042   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37043   Dali::TapGestureDetector *arg2 = 0 ;
37044   Dali::TapGestureDetector *result = 0 ;
37045
37046   arg1 = (Dali::TapGestureDetector *)jarg1;
37047   arg2 = (Dali::TapGestureDetector *)jarg2;
37048   if (!arg2) {
37049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37050     return 0;
37051   }
37052   {
37053     try {
37054       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37055     } catch (std::out_of_range& e) {
37056       {
37057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (std::exception& e) {
37060       {
37061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (...) {
37064       {
37065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37066       };
37067     }
37068   }
37069   jresult = (void *)result;
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37075   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37076   unsigned int arg2 ;
37077
37078   arg1 = (Dali::TapGestureDetector *)jarg1;
37079   arg2 = (unsigned int)jarg2;
37080   {
37081     try {
37082       (arg1)->SetMinimumTapsRequired(arg2);
37083     } catch (std::out_of_range& e) {
37084       {
37085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37086       };
37087     } catch (std::exception& e) {
37088       {
37089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37090       };
37091     } catch (...) {
37092       {
37093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37094       };
37095     }
37096   }
37097 }
37098
37099
37100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37101   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37102   unsigned int arg2 ;
37103
37104   arg1 = (Dali::TapGestureDetector *)jarg1;
37105   arg2 = (unsigned int)jarg2;
37106   {
37107     try {
37108       (arg1)->SetMaximumTapsRequired(arg2);
37109     } catch (std::out_of_range& e) {
37110       {
37111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37112       };
37113     } catch (std::exception& e) {
37114       {
37115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37120       };
37121     }
37122   }
37123 }
37124
37125
37126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37127   unsigned int jresult ;
37128   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37129   unsigned int result;
37130
37131   arg1 = (Dali::TapGestureDetector *)jarg1;
37132   {
37133     try {
37134       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37135     } catch (std::out_of_range& e) {
37136       {
37137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37138       };
37139     } catch (std::exception& e) {
37140       {
37141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37142       };
37143     } catch (...) {
37144       {
37145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37146       };
37147     }
37148   }
37149   jresult = result;
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37155   unsigned int jresult ;
37156   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37157   unsigned int result;
37158
37159   arg1 = (Dali::TapGestureDetector *)jarg1;
37160   {
37161     try {
37162       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37163     } catch (std::out_of_range& e) {
37164       {
37165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37166       };
37167     } catch (std::exception& e) {
37168       {
37169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37170       };
37171     } catch (...) {
37172       {
37173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37174       };
37175     }
37176   }
37177   jresult = result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37183   void * jresult ;
37184   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37185   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37186
37187   arg1 = (Dali::TapGestureDetector *)jarg1;
37188   {
37189     try {
37190       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37191     } catch (std::out_of_range& e) {
37192       {
37193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (std::exception& e) {
37196       {
37197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205   jresult = (void *)result;
37206   return jresult;
37207 }
37208
37209
37210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37211   void * jresult ;
37212   Dali::TapGesture *result = 0 ;
37213
37214   {
37215     try {
37216       result = (Dali::TapGesture *)new Dali::TapGesture();
37217     } catch (std::out_of_range& e) {
37218       {
37219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37220       };
37221     } catch (std::exception& e) {
37222       {
37223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37224       };
37225     } catch (...) {
37226       {
37227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37228       };
37229     }
37230   }
37231   jresult = (void *)result;
37232   return jresult;
37233 }
37234
37235
37236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37237   void * jresult ;
37238   Dali::TapGesture *arg1 = 0 ;
37239   Dali::TapGesture *result = 0 ;
37240
37241   arg1 = (Dali::TapGesture *)jarg1;
37242   if (!arg1) {
37243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37244     return 0;
37245   }
37246   {
37247     try {
37248       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37249     } catch (std::out_of_range& e) {
37250       {
37251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37252       };
37253     } catch (std::exception& e) {
37254       {
37255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37256       };
37257     } catch (...) {
37258       {
37259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37260       };
37261     }
37262   }
37263   jresult = (void *)result;
37264   return jresult;
37265 }
37266
37267
37268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37269   void * jresult ;
37270   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37271   Dali::TapGesture *arg2 = 0 ;
37272   Dali::TapGesture *result = 0 ;
37273
37274   arg1 = (Dali::TapGesture *)jarg1;
37275   arg2 = (Dali::TapGesture *)jarg2;
37276   if (!arg2) {
37277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37278     return 0;
37279   }
37280   {
37281     try {
37282       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37290       };
37291     } catch (...) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37294       };
37295     }
37296   }
37297   jresult = (void *)result;
37298   return jresult;
37299 }
37300
37301
37302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37303   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37304
37305   arg1 = (Dali::TapGesture *)jarg1;
37306   {
37307     try {
37308       delete arg1;
37309     } catch (std::out_of_range& e) {
37310       {
37311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37312       };
37313     } catch (std::exception& e) {
37314       {
37315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37316       };
37317     } catch (...) {
37318       {
37319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37320       };
37321     }
37322   }
37323 }
37324
37325
37326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37327   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37328   unsigned int arg2 ;
37329
37330   arg1 = (Dali::TapGesture *)jarg1;
37331   arg2 = (unsigned int)jarg2;
37332   if (arg1) (arg1)->numberOfTaps = arg2;
37333 }
37334
37335
37336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37337   unsigned int jresult ;
37338   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37339   unsigned int result;
37340
37341   arg1 = (Dali::TapGesture *)jarg1;
37342   result = (unsigned int) ((arg1)->numberOfTaps);
37343   jresult = result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37349   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37350   unsigned int arg2 ;
37351
37352   arg1 = (Dali::TapGesture *)jarg1;
37353   arg2 = (unsigned int)jarg2;
37354   if (arg1) (arg1)->numberOfTouches = arg2;
37355 }
37356
37357
37358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37359   unsigned int jresult ;
37360   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37361   unsigned int result;
37362
37363   arg1 = (Dali::TapGesture *)jarg1;
37364   result = (unsigned int) ((arg1)->numberOfTouches);
37365   jresult = result;
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37371   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37373
37374   arg1 = (Dali::TapGesture *)jarg1;
37375   arg2 = (Dali::Vector2 *)jarg2;
37376   if (arg1) (arg1)->screenPoint = *arg2;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37381   void * jresult ;
37382   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37383   Dali::Vector2 *result = 0 ;
37384
37385   arg1 = (Dali::TapGesture *)jarg1;
37386   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37393   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37394   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37395
37396   arg1 = (Dali::TapGesture *)jarg1;
37397   arg2 = (Dali::Vector2 *)jarg2;
37398   if (arg1) (arg1)->localPoint = *arg2;
37399 }
37400
37401
37402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37403   void * jresult ;
37404   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37405   Dali::Vector2 *result = 0 ;
37406
37407   arg1 = (Dali::TapGesture *)jarg1;
37408   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37409   jresult = (void *)result;
37410   return jresult;
37411 }
37412
37413
37414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37415   void * jresult ;
37416   Dali::AlphaFunction *result = 0 ;
37417
37418   {
37419     try {
37420       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37421     } catch (std::out_of_range& e) {
37422       {
37423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37424       };
37425     } catch (std::exception& e) {
37426       {
37427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37428       };
37429     } catch (...) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37432       };
37433     }
37434   }
37435   jresult = (void *)result;
37436   return jresult;
37437 }
37438
37439
37440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37441   void * jresult ;
37442   Dali::AlphaFunction::BuiltinFunction arg1 ;
37443   Dali::AlphaFunction *result = 0 ;
37444
37445   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37446   {
37447     try {
37448       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37449     } catch (std::out_of_range& e) {
37450       {
37451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37452       };
37453     } catch (std::exception& e) {
37454       {
37455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37456       };
37457     } catch (...) {
37458       {
37459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37460       };
37461     }
37462   }
37463   jresult = (void *)result;
37464   return jresult;
37465 }
37466
37467
37468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37469   void * jresult ;
37470   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37471   Dali::AlphaFunction *result = 0 ;
37472
37473   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37474   {
37475     try {
37476       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37477     } catch (std::out_of_range& e) {
37478       {
37479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37480       };
37481     } catch (std::exception& e) {
37482       {
37483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37484       };
37485     } catch (...) {
37486       {
37487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37488       };
37489     }
37490   }
37491   jresult = (void *)result;
37492   return jresult;
37493 }
37494
37495
37496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37497   void * jresult ;
37498   Dali::Vector2 *arg1 = 0 ;
37499   Dali::Vector2 *arg2 = 0 ;
37500   Dali::AlphaFunction *result = 0 ;
37501
37502   arg1 = (Dali::Vector2 *)jarg1;
37503   if (!arg1) {
37504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37505     return 0;
37506   }
37507   arg2 = (Dali::Vector2 *)jarg2;
37508   if (!arg2) {
37509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37510     return 0;
37511   }
37512   {
37513     try {
37514       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37515     } catch (std::out_of_range& e) {
37516       {
37517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37518       };
37519     } catch (std::exception& e) {
37520       {
37521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37522       };
37523     } catch (...) {
37524       {
37525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37526       };
37527     }
37528   }
37529   jresult = (void *)result;
37530   return jresult;
37531 }
37532
37533
37534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37535   void * jresult ;
37536   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37537   Dali::Vector4 result;
37538
37539   arg1 = (Dali::AlphaFunction *)jarg1;
37540   {
37541     try {
37542       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37543     } catch (std::out_of_range& e) {
37544       {
37545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37546       };
37547     } catch (std::exception& e) {
37548       {
37549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37550       };
37551     } catch (...) {
37552       {
37553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37554       };
37555     }
37556   }
37557   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37558   return jresult;
37559 }
37560
37561
37562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37563   void * jresult ;
37564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37565   Dali::AlphaFunctionPrototype result;
37566
37567   arg1 = (Dali::AlphaFunction *)jarg1;
37568   {
37569     try {
37570       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37571     } catch (std::out_of_range& e) {
37572       {
37573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37574       };
37575     } catch (std::exception& e) {
37576       {
37577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37578       };
37579     } catch (...) {
37580       {
37581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37582       };
37583     }
37584   }
37585   jresult = (void *)result;
37586   return jresult;
37587 }
37588
37589
37590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37591   int jresult ;
37592   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37593   Dali::AlphaFunction::BuiltinFunction result;
37594
37595   arg1 = (Dali::AlphaFunction *)jarg1;
37596   {
37597     try {
37598       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37606       };
37607     } catch (...) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37610       };
37611     }
37612   }
37613   jresult = (int)result;
37614   return jresult;
37615 }
37616
37617
37618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37619   int jresult ;
37620   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37621   Dali::AlphaFunction::Mode result;
37622
37623   arg1 = (Dali::AlphaFunction *)jarg1;
37624   {
37625     try {
37626       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37627     } catch (std::out_of_range& e) {
37628       {
37629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37630       };
37631     } catch (std::exception& e) {
37632       {
37633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37634       };
37635     } catch (...) {
37636       {
37637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37638       };
37639     }
37640   }
37641   jresult = (int)result;
37642   return jresult;
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37647   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37648
37649   arg1 = (Dali::AlphaFunction *)jarg1;
37650   {
37651     try {
37652       delete arg1;
37653     } catch (std::out_of_range& e) {
37654       {
37655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (std::exception& e) {
37658       {
37659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (...) {
37662       {
37663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37664       };
37665     }
37666   }
37667 }
37668
37669
37670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37671   void * jresult ;
37672   Dali::KeyFrames result;
37673
37674   {
37675     try {
37676       result = Dali::KeyFrames::New();
37677     } catch (std::out_of_range& e) {
37678       {
37679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37680       };
37681     } catch (std::exception& e) {
37682       {
37683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37684       };
37685     } catch (...) {
37686       {
37687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37688       };
37689     }
37690   }
37691   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37692   return jresult;
37693 }
37694
37695
37696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37697   void * jresult ;
37698   Dali::BaseHandle arg1 ;
37699   Dali::BaseHandle *argp1 ;
37700   Dali::KeyFrames result;
37701
37702   argp1 = (Dali::BaseHandle *)jarg1;
37703   if (!argp1) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37705     return 0;
37706   }
37707   arg1 = *argp1;
37708   {
37709     try {
37710       result = Dali::KeyFrames::DownCast(arg1);
37711     } catch (std::out_of_range& e) {
37712       {
37713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37714       };
37715     } catch (std::exception& e) {
37716       {
37717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (...) {
37720       {
37721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37722       };
37723     }
37724   }
37725   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37726   return jresult;
37727 }
37728
37729
37730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37731   void * jresult ;
37732   Dali::KeyFrames *result = 0 ;
37733
37734   {
37735     try {
37736       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37737     } catch (std::out_of_range& e) {
37738       {
37739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37740       };
37741     } catch (std::exception& e) {
37742       {
37743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37748       };
37749     }
37750   }
37751   jresult = (void *)result;
37752   return jresult;
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37757   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37758
37759   arg1 = (Dali::KeyFrames *)jarg1;
37760   {
37761     try {
37762       delete arg1;
37763     } catch (std::out_of_range& e) {
37764       {
37765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37766       };
37767     } catch (std::exception& e) {
37768       {
37769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37770       };
37771     } catch (...) {
37772       {
37773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37774       };
37775     }
37776   }
37777 }
37778
37779
37780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37781   void * jresult ;
37782   Dali::KeyFrames *arg1 = 0 ;
37783   Dali::KeyFrames *result = 0 ;
37784
37785   arg1 = (Dali::KeyFrames *)jarg1;
37786   if (!arg1) {
37787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37788     return 0;
37789   }
37790   {
37791     try {
37792       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37804       };
37805     }
37806   }
37807   jresult = (void *)result;
37808   return jresult;
37809 }
37810
37811
37812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37813   void * jresult ;
37814   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37815   Dali::KeyFrames *arg2 = 0 ;
37816   Dali::KeyFrames *result = 0 ;
37817
37818   arg1 = (Dali::KeyFrames *)jarg1;
37819   arg2 = (Dali::KeyFrames *)jarg2;
37820   if (!arg2) {
37821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37822     return 0;
37823   }
37824   {
37825     try {
37826       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37827     } catch (std::out_of_range& e) {
37828       {
37829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37830       };
37831     } catch (std::exception& e) {
37832       {
37833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37834       };
37835     } catch (...) {
37836       {
37837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37838       };
37839     }
37840   }
37841   jresult = (void *)result;
37842   return jresult;
37843 }
37844
37845
37846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37847   int jresult ;
37848   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37849   Dali::Property::Type result;
37850
37851   arg1 = (Dali::KeyFrames *)jarg1;
37852   {
37853     try {
37854       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37855     } catch (std::out_of_range& e) {
37856       {
37857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37858       };
37859     } catch (std::exception& e) {
37860       {
37861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37862       };
37863     } catch (...) {
37864       {
37865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37866       };
37867     }
37868   }
37869   jresult = (int)result;
37870   return jresult;
37871 }
37872
37873
37874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37875   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37876   float arg2 ;
37877   Dali::Property::Value arg3 ;
37878   Dali::Property::Value *argp3 ;
37879
37880   arg1 = (Dali::KeyFrames *)jarg1;
37881   arg2 = (float)jarg2;
37882   argp3 = (Dali::Property::Value *)jarg3;
37883   if (!argp3) {
37884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37885     return ;
37886   }
37887   arg3 = *argp3;
37888   {
37889     try {
37890       (arg1)->Add(arg2,arg3);
37891     } catch (std::out_of_range& e) {
37892       {
37893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37894       };
37895     } catch (std::exception& e) {
37896       {
37897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37898       };
37899     } catch (...) {
37900       {
37901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37902       };
37903     }
37904   }
37905 }
37906
37907
37908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37909   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37910   float arg2 ;
37911   Dali::Property::Value arg3 ;
37912   Dali::AlphaFunction arg4 ;
37913   Dali::Property::Value *argp3 ;
37914   Dali::AlphaFunction *argp4 ;
37915
37916   arg1 = (Dali::KeyFrames *)jarg1;
37917   arg2 = (float)jarg2;
37918   argp3 = (Dali::Property::Value *)jarg3;
37919   if (!argp3) {
37920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37921     return ;
37922   }
37923   arg3 = *argp3;
37924   argp4 = (Dali::AlphaFunction *)jarg4;
37925   if (!argp4) {
37926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37927     return ;
37928   }
37929   arg4 = *argp4;
37930   {
37931     try {
37932       (arg1)->Add(arg2,arg3,arg4);
37933     } catch (std::out_of_range& e) {
37934       {
37935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37936       };
37937     } catch (std::exception& e) {
37938       {
37939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37940       };
37941     } catch (...) {
37942       {
37943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37944       };
37945     }
37946   }
37947 }
37948
37949
37950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37951   int jresult ;
37952   int result;
37953
37954   result = (int)Dali::Path::Property::POINTS;
37955   jresult = (int)result;
37956   return jresult;
37957 }
37958
37959
37960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37961   int jresult ;
37962   int result;
37963
37964   result = (int)Dali::Path::Property::CONTROL_POINTS;
37965   jresult = (int)result;
37966   return jresult;
37967 }
37968
37969
37970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37971   void * jresult ;
37972   Dali::Path::Property *result = 0 ;
37973
37974   {
37975     try {
37976       result = (Dali::Path::Property *)new Dali::Path::Property();
37977     } catch (std::out_of_range& e) {
37978       {
37979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37980       };
37981     } catch (std::exception& e) {
37982       {
37983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37984       };
37985     } catch (...) {
37986       {
37987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37988       };
37989     }
37990   }
37991   jresult = (void *)result;
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37997   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37998
37999   arg1 = (Dali::Path::Property *)jarg1;
38000   {
38001     try {
38002       delete arg1;
38003     } catch (std::out_of_range& e) {
38004       {
38005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38006       };
38007     } catch (std::exception& e) {
38008       {
38009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38010       };
38011     } catch (...) {
38012       {
38013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38014       };
38015     }
38016   }
38017 }
38018
38019
38020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38021   void * jresult ;
38022   Dali::Path result;
38023
38024   {
38025     try {
38026       result = Dali::Path::New();
38027     } catch (std::out_of_range& e) {
38028       {
38029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38030       };
38031     } catch (std::exception& e) {
38032       {
38033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38034       };
38035     } catch (...) {
38036       {
38037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38038       };
38039     }
38040   }
38041   jresult = new Dali::Path((const Dali::Path &)result);
38042   return jresult;
38043 }
38044
38045
38046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38047   void * jresult ;
38048   Dali::BaseHandle arg1 ;
38049   Dali::BaseHandle *argp1 ;
38050   Dali::Path result;
38051
38052   argp1 = (Dali::BaseHandle *)jarg1;
38053   if (!argp1) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38055     return 0;
38056   }
38057   arg1 = *argp1;
38058   {
38059     try {
38060       result = Dali::Path::DownCast(arg1);
38061     } catch (std::out_of_range& e) {
38062       {
38063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38064       };
38065     } catch (std::exception& e) {
38066       {
38067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38072       };
38073     }
38074   }
38075   jresult = new Dali::Path((const Dali::Path &)result);
38076   return jresult;
38077 }
38078
38079
38080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38081   void * jresult ;
38082   Dali::Path *result = 0 ;
38083
38084   {
38085     try {
38086       result = (Dali::Path *)new Dali::Path();
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101   jresult = (void *)result;
38102   return jresult;
38103 }
38104
38105
38106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38107   Dali::Path *arg1 = (Dali::Path *) 0 ;
38108
38109   arg1 = (Dali::Path *)jarg1;
38110   {
38111     try {
38112       delete arg1;
38113     } catch (std::out_of_range& e) {
38114       {
38115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38116       };
38117     } catch (std::exception& e) {
38118       {
38119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38120       };
38121     } catch (...) {
38122       {
38123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38124       };
38125     }
38126   }
38127 }
38128
38129
38130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38131   void * jresult ;
38132   Dali::Path *arg1 = 0 ;
38133   Dali::Path *result = 0 ;
38134
38135   arg1 = (Dali::Path *)jarg1;
38136   if (!arg1) {
38137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38138     return 0;
38139   }
38140   {
38141     try {
38142       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38143     } catch (std::out_of_range& e) {
38144       {
38145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38146       };
38147     } catch (std::exception& e) {
38148       {
38149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38150       };
38151     } catch (...) {
38152       {
38153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38154       };
38155     }
38156   }
38157   jresult = (void *)result;
38158   return jresult;
38159 }
38160
38161
38162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38163   void * jresult ;
38164   Dali::Path *arg1 = (Dali::Path *) 0 ;
38165   Dali::Path *arg2 = 0 ;
38166   Dali::Path *result = 0 ;
38167
38168   arg1 = (Dali::Path *)jarg1;
38169   arg2 = (Dali::Path *)jarg2;
38170   if (!arg2) {
38171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38172     return 0;
38173   }
38174   {
38175     try {
38176       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38177     } catch (std::out_of_range& e) {
38178       {
38179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38180       };
38181     } catch (std::exception& e) {
38182       {
38183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (...) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38188       };
38189     }
38190   }
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38197   Dali::Path *arg1 = (Dali::Path *) 0 ;
38198   Dali::Vector3 *arg2 = 0 ;
38199
38200   arg1 = (Dali::Path *)jarg1;
38201   arg2 = (Dali::Vector3 *)jarg2;
38202   if (!arg2) {
38203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38204     return ;
38205   }
38206   {
38207     try {
38208       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38209     } catch (std::out_of_range& e) {
38210       {
38211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38212       };
38213     } catch (std::exception& e) {
38214       {
38215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38216       };
38217     } catch (...) {
38218       {
38219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38220       };
38221     }
38222   }
38223 }
38224
38225
38226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38227   Dali::Path *arg1 = (Dali::Path *) 0 ;
38228   Dali::Vector3 *arg2 = 0 ;
38229
38230   arg1 = (Dali::Path *)jarg1;
38231   arg2 = (Dali::Vector3 *)jarg2;
38232   if (!arg2) {
38233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38234     return ;
38235   }
38236   {
38237     try {
38238       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38239     } catch (std::out_of_range& e) {
38240       {
38241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38242       };
38243     } catch (std::exception& e) {
38244       {
38245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38246       };
38247     } catch (...) {
38248       {
38249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38250       };
38251     }
38252   }
38253 }
38254
38255
38256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38257   Dali::Path *arg1 = (Dali::Path *) 0 ;
38258   float arg2 ;
38259
38260   arg1 = (Dali::Path *)jarg1;
38261   arg2 = (float)jarg2;
38262   {
38263     try {
38264       (arg1)->GenerateControlPoints(arg2);
38265     } catch (std::out_of_range& e) {
38266       {
38267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38268       };
38269     } catch (std::exception& e) {
38270       {
38271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38272       };
38273     } catch (...) {
38274       {
38275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38276       };
38277     }
38278   }
38279 }
38280
38281
38282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38283   Dali::Path *arg1 = (Dali::Path *) 0 ;
38284   float arg2 ;
38285   Dali::Vector3 *arg3 = 0 ;
38286   Dali::Vector3 *arg4 = 0 ;
38287
38288   arg1 = (Dali::Path *)jarg1;
38289   arg2 = (float)jarg2;
38290   arg3 = (Dali::Vector3 *)jarg3;
38291   if (!arg3) {
38292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38293     return ;
38294   }
38295   arg4 = (Dali::Vector3 *)jarg4;
38296   if (!arg4) {
38297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38298     return ;
38299   }
38300   {
38301     try {
38302       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38314       };
38315     }
38316   }
38317 }
38318
38319
38320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38321   void * jresult ;
38322   Dali::Path *arg1 = (Dali::Path *) 0 ;
38323   size_t arg2 ;
38324   Dali::Vector3 *result = 0 ;
38325
38326   arg1 = (Dali::Path *)jarg1;
38327   arg2 = (size_t)jarg2;
38328   {
38329     try {
38330       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (...) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38342       };
38343     }
38344   }
38345   jresult = (void *)result;
38346   return jresult;
38347 }
38348
38349
38350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38351   void * jresult ;
38352   Dali::Path *arg1 = (Dali::Path *) 0 ;
38353   size_t arg2 ;
38354   Dali::Vector3 *result = 0 ;
38355
38356   arg1 = (Dali::Path *)jarg1;
38357   arg2 = (size_t)jarg2;
38358   {
38359     try {
38360       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375   jresult = (void *)result;
38376   return jresult;
38377 }
38378
38379
38380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38381   unsigned long jresult ;
38382   Dali::Path *arg1 = (Dali::Path *) 0 ;
38383   size_t result;
38384
38385   arg1 = (Dali::Path *)jarg1;
38386   {
38387     try {
38388       result = ((Dali::Path const *)arg1)->GetPointCount();
38389     } catch (std::out_of_range& e) {
38390       {
38391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38392       };
38393     } catch (std::exception& e) {
38394       {
38395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38396       };
38397     } catch (...) {
38398       {
38399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38400       };
38401     }
38402   }
38403   jresult = (unsigned long)result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38409   void * jresult ;
38410   float arg1 ;
38411   Dali::TimePeriod *result = 0 ;
38412
38413   arg1 = (float)jarg1;
38414   {
38415     try {
38416       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (...) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38428       };
38429     }
38430   }
38431   jresult = (void *)result;
38432   return jresult;
38433 }
38434
38435
38436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38437   void * jresult ;
38438   float arg1 ;
38439   float arg2 ;
38440   Dali::TimePeriod *result = 0 ;
38441
38442   arg1 = (float)jarg1;
38443   arg2 = (float)jarg2;
38444   {
38445     try {
38446       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38447     } catch (std::out_of_range& e) {
38448       {
38449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38450       };
38451     } catch (std::exception& e) {
38452       {
38453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (...) {
38456       {
38457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38458       };
38459     }
38460   }
38461   jresult = (void *)result;
38462   return jresult;
38463 }
38464
38465
38466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38467   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38468
38469   arg1 = (Dali::TimePeriod *)jarg1;
38470   {
38471     try {
38472       delete arg1;
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (...) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38484       };
38485     }
38486   }
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38491   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38492   float arg2 ;
38493
38494   arg1 = (Dali::TimePeriod *)jarg1;
38495   arg2 = (float)jarg2;
38496   if (arg1) (arg1)->delaySeconds = arg2;
38497 }
38498
38499
38500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38501   float jresult ;
38502   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38503   float result;
38504
38505   arg1 = (Dali::TimePeriod *)jarg1;
38506   result = (float) ((arg1)->delaySeconds);
38507   jresult = result;
38508   return jresult;
38509 }
38510
38511
38512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38513   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38514   float arg2 ;
38515
38516   arg1 = (Dali::TimePeriod *)jarg1;
38517   arg2 = (float)jarg2;
38518   if (arg1) (arg1)->durationSeconds = arg2;
38519 }
38520
38521
38522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38523   float jresult ;
38524   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38525   float result;
38526
38527   arg1 = (Dali::TimePeriod *)jarg1;
38528   result = (float) ((arg1)->durationSeconds);
38529   jresult = result;
38530   return jresult;
38531 }
38532
38533
38534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38535   void * jresult ;
38536   Dali::Animation *result = 0 ;
38537
38538   {
38539     try {
38540       result = (Dali::Animation *)new Dali::Animation();
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555   jresult = (void *)result;
38556   return jresult;
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38561   void * jresult ;
38562   float arg1 ;
38563   Dali::Animation result;
38564
38565   arg1 = (float)jarg1;
38566   {
38567     try {
38568       result = Dali::Animation::New(arg1);
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 = new Dali::Animation((const Dali::Animation &)result);
38584   return jresult;
38585 }
38586
38587
38588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38589   void * jresult ;
38590   Dali::BaseHandle arg1 ;
38591   Dali::BaseHandle *argp1 ;
38592   Dali::Animation result;
38593
38594   argp1 = (Dali::BaseHandle *)jarg1;
38595   if (!argp1) {
38596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38597     return 0;
38598   }
38599   arg1 = *argp1;
38600   {
38601     try {
38602       result = Dali::Animation::DownCast(arg1);
38603     } catch (std::out_of_range& e) {
38604       {
38605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38606       };
38607     } catch (std::exception& e) {
38608       {
38609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38614       };
38615     }
38616   }
38617   jresult = new Dali::Animation((const Dali::Animation &)result);
38618   return jresult;
38619 }
38620
38621
38622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38623   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38624
38625   arg1 = (Dali::Animation *)jarg1;
38626   {
38627     try {
38628       delete arg1;
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38640       };
38641     }
38642   }
38643 }
38644
38645
38646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38647   void * jresult ;
38648   Dali::Animation *arg1 = 0 ;
38649   Dali::Animation *result = 0 ;
38650
38651   arg1 = (Dali::Animation *)jarg1;
38652   if (!arg1) {
38653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38654     return 0;
38655   }
38656   {
38657     try {
38658       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
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_Animation_Assign(void * jarg1, void * jarg2) {
38679   void * jresult ;
38680   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38681   Dali::Animation *arg2 = 0 ;
38682   Dali::Animation *result = 0 ;
38683
38684   arg1 = (Dali::Animation *)jarg1;
38685   arg2 = (Dali::Animation *)jarg2;
38686   if (!arg2) {
38687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38688     return 0;
38689   }
38690   {
38691     try {
38692       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38693     } catch (std::out_of_range& e) {
38694       {
38695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38696       };
38697     } catch (std::exception& e) {
38698       {
38699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (...) {
38702       {
38703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38704       };
38705     }
38706   }
38707   jresult = (void *)result;
38708   return jresult;
38709 }
38710
38711
38712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38713   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38714   float arg2 ;
38715
38716   arg1 = (Dali::Animation *)jarg1;
38717   arg2 = (float)jarg2;
38718   {
38719     try {
38720       (arg1)->SetDuration(arg2);
38721     } catch (std::out_of_range& e) {
38722       {
38723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38724       };
38725     } catch (std::exception& e) {
38726       {
38727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38728       };
38729     } catch (...) {
38730       {
38731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38732       };
38733     }
38734   }
38735 }
38736
38737
38738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38739   float jresult ;
38740   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38741   float result;
38742
38743   arg1 = (Dali::Animation *)jarg1;
38744   {
38745     try {
38746       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38747     } catch (std::out_of_range& e) {
38748       {
38749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (std::exception& e) {
38752       {
38753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761   jresult = result;
38762   return jresult;
38763 }
38764
38765
38766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38767   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38768   bool arg2 ;
38769
38770   arg1 = (Dali::Animation *)jarg1;
38771   arg2 = jarg2 ? true : false;
38772   {
38773     try {
38774       (arg1)->SetLooping(arg2);
38775     } catch (std::out_of_range& e) {
38776       {
38777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38778       };
38779     } catch (std::exception& e) {
38780       {
38781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38782       };
38783     } catch (...) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38786       };
38787     }
38788   }
38789 }
38790
38791
38792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   int arg2 ;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   arg2 = (int)jarg2;
38798   {
38799     try {
38800       (arg1)->SetLoopCount(arg2);
38801     } catch (std::out_of_range& e) {
38802       {
38803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38804       };
38805     } catch (std::exception& e) {
38806       {
38807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38808       };
38809     } catch (...) {
38810       {
38811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38812       };
38813     }
38814   }
38815 }
38816
38817
38818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38819   int jresult ;
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   int result;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   {
38825     try {
38826       result = (int)(arg1)->GetLoopCount();
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38838       };
38839     }
38840   }
38841   jresult = result;
38842   return jresult;
38843 }
38844
38845
38846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38847   int jresult ;
38848   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38849   int result;
38850
38851   arg1 = (Dali::Animation *)jarg1;
38852   {
38853     try {
38854       result = (int)(arg1)->GetCurrentLoop();
38855     } catch (std::out_of_range& e) {
38856       {
38857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38858       };
38859     } catch (std::exception& e) {
38860       {
38861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38862       };
38863     } catch (...) {
38864       {
38865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38866       };
38867     }
38868   }
38869   jresult = result;
38870   return jresult;
38871 }
38872
38873
38874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38875   unsigned int jresult ;
38876   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38877   bool result;
38878
38879   arg1 = (Dali::Animation *)jarg1;
38880   {
38881     try {
38882       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38883     } catch (std::out_of_range& e) {
38884       {
38885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (std::exception& e) {
38888       {
38889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897   jresult = result;
38898   return jresult;
38899 }
38900
38901
38902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38903   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38904   Dali::Animation::EndAction arg2 ;
38905
38906   arg1 = (Dali::Animation *)jarg1;
38907   arg2 = (Dali::Animation::EndAction)jarg2;
38908   {
38909     try {
38910       (arg1)->SetEndAction(arg2);
38911     } catch (std::out_of_range& e) {
38912       {
38913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38914       };
38915     } catch (std::exception& e) {
38916       {
38917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38918       };
38919     } catch (...) {
38920       {
38921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38922       };
38923     }
38924   }
38925 }
38926
38927
38928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38929   int jresult ;
38930   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38931   Dali::Animation::EndAction result;
38932
38933   arg1 = (Dali::Animation *)jarg1;
38934   {
38935     try {
38936       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38937     } catch (std::out_of_range& e) {
38938       {
38939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38940       };
38941     } catch (std::exception& e) {
38942       {
38943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38944       };
38945     } catch (...) {
38946       {
38947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38948       };
38949     }
38950   }
38951   jresult = (int)result;
38952   return jresult;
38953 }
38954
38955
38956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38957   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38958   Dali::Animation::EndAction arg2 ;
38959
38960   arg1 = (Dali::Animation *)jarg1;
38961   arg2 = (Dali::Animation::EndAction)jarg2;
38962   {
38963     try {
38964       (arg1)->SetDisconnectAction(arg2);
38965     } catch (std::out_of_range& e) {
38966       {
38967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38968       };
38969     } catch (std::exception& e) {
38970       {
38971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38972       };
38973     } catch (...) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38976       };
38977     }
38978   }
38979 }
38980
38981
38982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38983   int jresult ;
38984   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38985   Dali::Animation::EndAction result;
38986
38987   arg1 = (Dali::Animation *)jarg1;
38988   {
38989     try {
38990       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38991     } catch (std::out_of_range& e) {
38992       {
38993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38994       };
38995     } catch (std::exception& e) {
38996       {
38997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38998       };
38999     } catch (...) {
39000       {
39001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39002       };
39003     }
39004   }
39005   jresult = (int)result;
39006   return jresult;
39007 }
39008
39009
39010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39011   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39012   Dali::AlphaFunction arg2 ;
39013   Dali::AlphaFunction *argp2 ;
39014
39015   arg1 = (Dali::Animation *)jarg1;
39016   argp2 = (Dali::AlphaFunction *)jarg2;
39017   if (!argp2) {
39018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39019     return ;
39020   }
39021   arg2 = *argp2;
39022   {
39023     try {
39024       (arg1)->SetDefaultAlphaFunction(arg2);
39025     } catch (std::out_of_range& e) {
39026       {
39027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (std::exception& e) {
39030       {
39031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39032       };
39033     } catch (...) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39036       };
39037     }
39038   }
39039 }
39040
39041
39042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39043   void * jresult ;
39044   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39045   Dali::AlphaFunction result;
39046
39047   arg1 = (Dali::Animation *)jarg1;
39048   {
39049     try {
39050       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39051     } catch (std::out_of_range& e) {
39052       {
39053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39054       };
39055     } catch (std::exception& e) {
39056       {
39057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39058       };
39059     } catch (...) {
39060       {
39061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39062       };
39063     }
39064   }
39065   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39066   return jresult;
39067 }
39068
39069
39070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39071   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39072   float arg2 ;
39073
39074   arg1 = (Dali::Animation *)jarg1;
39075   arg2 = (float)jarg2;
39076   {
39077     try {
39078       (arg1)->SetCurrentProgress(arg2);
39079     } catch (std::out_of_range& e) {
39080       {
39081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39082       };
39083     } catch (std::exception& e) {
39084       {
39085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39090       };
39091     }
39092   }
39093 }
39094
39095
39096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39097   float jresult ;
39098   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39099   float result;
39100
39101   arg1 = (Dali::Animation *)jarg1;
39102   {
39103     try {
39104       result = (float)(arg1)->GetCurrentProgress();
39105     } catch (std::out_of_range& e) {
39106       {
39107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39108       };
39109     } catch (std::exception& e) {
39110       {
39111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39112       };
39113     } catch (...) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39116       };
39117     }
39118   }
39119   jresult = result;
39120   return jresult;
39121 }
39122
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39125   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39126   float arg2 ;
39127
39128   arg1 = (Dali::Animation *)jarg1;
39129   arg2 = (float)jarg2;
39130   {
39131     try {
39132       (arg1)->SetSpeedFactor(arg2);
39133     } catch (std::out_of_range& e) {
39134       {
39135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39136       };
39137     } catch (std::exception& e) {
39138       {
39139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39140       };
39141     } catch (...) {
39142       {
39143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39144       };
39145     }
39146   }
39147 }
39148
39149
39150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39151   float jresult ;
39152   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39153   float result;
39154
39155   arg1 = (Dali::Animation *)jarg1;
39156   {
39157     try {
39158       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39159     } catch (std::out_of_range& e) {
39160       {
39161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39162       };
39163     } catch (std::exception& e) {
39164       {
39165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39166       };
39167     } catch (...) {
39168       {
39169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39170       };
39171     }
39172   }
39173   jresult = result;
39174   return jresult;
39175 }
39176
39177
39178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39179   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39180   Dali::Vector2 *arg2 = 0 ;
39181
39182   arg1 = (Dali::Animation *)jarg1;
39183   arg2 = (Dali::Vector2 *)jarg2;
39184   if (!arg2) {
39185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39186     return ;
39187   }
39188   {
39189     try {
39190       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39191     } catch (std::out_of_range& e) {
39192       {
39193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39194       };
39195     } catch (std::exception& e) {
39196       {
39197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39198       };
39199     } catch (...) {
39200       {
39201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39202       };
39203     }
39204   }
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39209   void * jresult ;
39210   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39211   Dali::Vector2 result;
39212
39213   arg1 = (Dali::Animation *)jarg1;
39214   {
39215     try {
39216       result = ((Dali::Animation const *)arg1)->GetPlayRange();
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 = new Dali::Vector2((const Dali::Vector2 &)result);
39232   return jresult;
39233 }
39234
39235
39236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39237   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39238
39239   arg1 = (Dali::Animation *)jarg1;
39240   {
39241     try {
39242       (arg1)->Play();
39243     } catch (std::out_of_range& e) {
39244       {
39245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (std::exception& e) {
39248       {
39249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257 }
39258
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39261   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39262   float arg2 ;
39263
39264   arg1 = (Dali::Animation *)jarg1;
39265   arg2 = (float)jarg2;
39266   {
39267     try {
39268       (arg1)->PlayFrom(arg2);
39269     } catch (std::out_of_range& e) {
39270       {
39271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (std::exception& e) {
39274       {
39275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283 }
39284
39285
39286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39287   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39288
39289   arg1 = (Dali::Animation *)jarg1;
39290   {
39291     try {
39292       (arg1)->Pause();
39293     } catch (std::out_of_range& e) {
39294       {
39295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39296       };
39297     } catch (std::exception& e) {
39298       {
39299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39300       };
39301     } catch (...) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39304       };
39305     }
39306   }
39307 }
39308
39309
39310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39311   int jresult ;
39312   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39313   Dali::Animation::State result;
39314
39315   arg1 = (Dali::Animation *)jarg1;
39316   {
39317     try {
39318       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39319     } catch (std::out_of_range& e) {
39320       {
39321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39322       };
39323     } catch (std::exception& e) {
39324       {
39325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39326       };
39327     } catch (...) {
39328       {
39329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39330       };
39331     }
39332   }
39333   jresult = (int)result;
39334   return jresult;
39335 }
39336
39337
39338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39339   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39340
39341   arg1 = (Dali::Animation *)jarg1;
39342   {
39343     try {
39344       (arg1)->Stop();
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (...) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39356       };
39357     }
39358   }
39359 }
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39362   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39363
39364   Dali::Animation arg1 = *argp1;
39365   float arg2 = (float)jarg2;
39366
39367   {
39368     try {
39369       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39370     } catch (std::out_of_range& e) {
39371       {
39372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (std::exception& e) {
39375       {
39376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39377       };
39378     } catch (...) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39381       };
39382     }
39383   }
39384 }
39385
39386
39387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39388   float jresult ;
39389   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39390   float result;
39391
39392   Dali::Animation arg1 = *argp1;
39393   {
39394     try {
39395       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
39396     } catch (std::out_of_range& e) {
39397       {
39398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39399       };
39400     } catch (std::exception& e) {
39401       {
39402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39407       };
39408     }
39409   }
39410   jresult = result;
39411   return jresult;
39412 }
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39415   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39416
39417   arg1 = (Dali::Animation *)jarg1;
39418   {
39419     try {
39420       (arg1)->Clear();
39421     } catch (std::out_of_range& e) {
39422       {
39423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39424       };
39425     } catch (std::exception& e) {
39426       {
39427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39428       };
39429     } catch (...) {
39430       {
39431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39432       };
39433     }
39434   }
39435 }
39436
39437
39438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39439   void * jresult ;
39440   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39441   Dali::Animation::AnimationSignalType *result = 0 ;
39442
39443   arg1 = (Dali::Animation *)jarg1;
39444   {
39445     try {
39446       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (...) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39458       };
39459     }
39460   }
39461   jresult = (void *)result;
39462   return jresult;
39463 }
39464
39465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39466   void * jresult ;
39467   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39468   Dali::Animation::AnimationSignalType *result = 0 ;
39469
39470   Dali::Animation arg1 = *argp1;
39471   {
39472     try {
39473       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39474     } catch (std::out_of_range& e) {
39475       {
39476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39477       };
39478     } catch (std::exception& e) {
39479       {
39480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39481       };
39482     } catch (...) {
39483       {
39484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39485       };
39486     }
39487   }
39488   jresult = (void *)result;
39489   return jresult;
39490 }
39491
39492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39493   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39494   SwigValueWrapper< Dali::Property > arg2 ;
39495   Dali::Property::Value arg3 ;
39496   Dali::Property *argp2 ;
39497   Dali::Property::Value *argp3 ;
39498
39499   arg1 = (Dali::Animation *)jarg1;
39500   argp2 = (Dali::Property *)jarg2;
39501   if (!argp2) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39503     return ;
39504   }
39505   arg2 = *argp2;
39506   argp3 = (Dali::Property::Value *)jarg3;
39507   if (!argp3) {
39508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39509     return ;
39510   }
39511   arg3 = *argp3;
39512   {
39513     try {
39514       (arg1)->AnimateBy(arg2,arg3);
39515     } catch (std::out_of_range& e) {
39516       {
39517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39518       };
39519     } catch (std::exception& e) {
39520       {
39521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39522       };
39523     } catch (...) {
39524       {
39525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39526       };
39527     }
39528   }
39529 }
39530
39531
39532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39533   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39534   SwigValueWrapper< Dali::Property > arg2 ;
39535   Dali::Property::Value arg3 ;
39536   Dali::AlphaFunction arg4 ;
39537   Dali::Property *argp2 ;
39538   Dali::Property::Value *argp3 ;
39539   Dali::AlphaFunction *argp4 ;
39540
39541   arg1 = (Dali::Animation *)jarg1;
39542   argp2 = (Dali::Property *)jarg2;
39543   if (!argp2) {
39544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39545     return ;
39546   }
39547   arg2 = *argp2;
39548   argp3 = (Dali::Property::Value *)jarg3;
39549   if (!argp3) {
39550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39551     return ;
39552   }
39553   arg3 = *argp3;
39554   argp4 = (Dali::AlphaFunction *)jarg4;
39555   if (!argp4) {
39556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39557     return ;
39558   }
39559   arg4 = *argp4;
39560   {
39561     try {
39562       (arg1)->AnimateBy(arg2,arg3,arg4);
39563     } catch (std::out_of_range& e) {
39564       {
39565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39566       };
39567     } catch (std::exception& e) {
39568       {
39569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39574       };
39575     }
39576   }
39577 }
39578
39579
39580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39581   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39582   SwigValueWrapper< Dali::Property > arg2 ;
39583   Dali::Property::Value arg3 ;
39584   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39585   Dali::Property *argp2 ;
39586   Dali::Property::Value *argp3 ;
39587   Dali::TimePeriod *argp4 ;
39588
39589   arg1 = (Dali::Animation *)jarg1;
39590   argp2 = (Dali::Property *)jarg2;
39591   if (!argp2) {
39592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39593     return ;
39594   }
39595   arg2 = *argp2;
39596   argp3 = (Dali::Property::Value *)jarg3;
39597   if (!argp3) {
39598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39599     return ;
39600   }
39601   arg3 = *argp3;
39602   argp4 = (Dali::TimePeriod *)jarg4;
39603   if (!argp4) {
39604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39605     return ;
39606   }
39607   arg4 = *argp4;
39608   {
39609     try {
39610       (arg1)->AnimateBy(arg2,arg3,arg4);
39611     } catch (std::out_of_range& e) {
39612       {
39613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39614       };
39615     } catch (std::exception& e) {
39616       {
39617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39618       };
39619     } catch (...) {
39620       {
39621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39622       };
39623     }
39624   }
39625 }
39626
39627
39628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39629   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39630   SwigValueWrapper< Dali::Property > arg2 ;
39631   Dali::Property::Value arg3 ;
39632   Dali::AlphaFunction arg4 ;
39633   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39634   Dali::Property *argp2 ;
39635   Dali::Property::Value *argp3 ;
39636   Dali::AlphaFunction *argp4 ;
39637   Dali::TimePeriod *argp5 ;
39638
39639   arg1 = (Dali::Animation *)jarg1;
39640   argp2 = (Dali::Property *)jarg2;
39641   if (!argp2) {
39642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39643     return ;
39644   }
39645   arg2 = *argp2;
39646   argp3 = (Dali::Property::Value *)jarg3;
39647   if (!argp3) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39649     return ;
39650   }
39651   arg3 = *argp3;
39652   argp4 = (Dali::AlphaFunction *)jarg4;
39653   if (!argp4) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39655     return ;
39656   }
39657   arg4 = *argp4;
39658   argp5 = (Dali::TimePeriod *)jarg5;
39659   if (!argp5) {
39660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39661     return ;
39662   }
39663   arg5 = *argp5;
39664   {
39665     try {
39666       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39667     } catch (std::out_of_range& e) {
39668       {
39669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39670       };
39671     } catch (std::exception& e) {
39672       {
39673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39674       };
39675     } catch (...) {
39676       {
39677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39678       };
39679     }
39680   }
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39685   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39686   SwigValueWrapper< Dali::Property > arg2 ;
39687   Dali::Property::Value arg3 ;
39688   Dali::Property *argp2 ;
39689   Dali::Property::Value *argp3 ;
39690
39691   arg1 = (Dali::Animation *)jarg1;
39692   argp2 = (Dali::Property *)jarg2;
39693   if (!argp2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39695     return ;
39696   }
39697   arg2 = *argp2;
39698   argp3 = (Dali::Property::Value *)jarg3;
39699   if (!argp3) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39701     return ;
39702   }
39703   arg3 = *argp3;
39704   {
39705     try {
39706       (arg1)->AnimateTo(arg2,arg3);
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 void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39725   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39726   SwigValueWrapper< Dali::Property > arg2 ;
39727   Dali::Property::Value arg3 ;
39728   Dali::AlphaFunction arg4 ;
39729   Dali::Property *argp2 ;
39730   Dali::Property::Value *argp3 ;
39731   Dali::AlphaFunction *argp4 ;
39732
39733   arg1 = (Dali::Animation *)jarg1;
39734   argp2 = (Dali::Property *)jarg2;
39735   if (!argp2) {
39736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39737     return ;
39738   }
39739   arg2 = *argp2;
39740   argp3 = (Dali::Property::Value *)jarg3;
39741   if (!argp3) {
39742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39743     return ;
39744   }
39745   arg3 = *argp3;
39746   argp4 = (Dali::AlphaFunction *)jarg4;
39747   if (!argp4) {
39748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39749     return ;
39750   }
39751   arg4 = *argp4;
39752   {
39753     try {
39754       (arg1)->AnimateTo(arg2,arg3,arg4);
39755     } catch (std::out_of_range& e) {
39756       {
39757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (std::exception& e) {
39760       {
39761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769 }
39770
39771
39772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39773   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39774   SwigValueWrapper< Dali::Property > arg2 ;
39775   Dali::Property::Value arg3 ;
39776   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39777   Dali::Property *argp2 ;
39778   Dali::Property::Value *argp3 ;
39779   Dali::TimePeriod *argp4 ;
39780
39781   arg1 = (Dali::Animation *)jarg1;
39782   argp2 = (Dali::Property *)jarg2;
39783   if (!argp2) {
39784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39785     return ;
39786   }
39787   arg2 = *argp2;
39788   argp3 = (Dali::Property::Value *)jarg3;
39789   if (!argp3) {
39790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39791     return ;
39792   }
39793   arg3 = *argp3;
39794   argp4 = (Dali::TimePeriod *)jarg4;
39795   if (!argp4) {
39796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39797     return ;
39798   }
39799   arg4 = *argp4;
39800   {
39801     try {
39802       (arg1)->AnimateTo(arg2,arg3,arg4);
39803     } catch (std::out_of_range& e) {
39804       {
39805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39806       };
39807     } catch (std::exception& e) {
39808       {
39809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39810       };
39811     } catch (...) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39814       };
39815     }
39816   }
39817 }
39818
39819
39820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39821   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39822   SwigValueWrapper< Dali::Property > arg2 ;
39823   Dali::Property::Value arg3 ;
39824   Dali::AlphaFunction arg4 ;
39825   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39826   Dali::Property *argp2 ;
39827   Dali::Property::Value *argp3 ;
39828   Dali::AlphaFunction *argp4 ;
39829   Dali::TimePeriod *argp5 ;
39830
39831   arg1 = (Dali::Animation *)jarg1;
39832   argp2 = (Dali::Property *)jarg2;
39833   if (!argp2) {
39834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39835     return ;
39836   }
39837   arg2 = *argp2;
39838   argp3 = (Dali::Property::Value *)jarg3;
39839   if (!argp3) {
39840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39841     return ;
39842   }
39843   arg3 = *argp3;
39844   argp4 = (Dali::AlphaFunction *)jarg4;
39845   if (!argp4) {
39846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39847     return ;
39848   }
39849   arg4 = *argp4;
39850   argp5 = (Dali::TimePeriod *)jarg5;
39851   if (!argp5) {
39852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39853     return ;
39854   }
39855   arg5 = *argp5;
39856   {
39857     try {
39858       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39859     } catch (std::out_of_range& e) {
39860       {
39861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39862       };
39863     } catch (std::exception& e) {
39864       {
39865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39866       };
39867     } catch (...) {
39868       {
39869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39870       };
39871     }
39872   }
39873 }
39874
39875
39876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39877   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39878   SwigValueWrapper< Dali::Property > arg2 ;
39879   Dali::KeyFrames *arg3 = 0 ;
39880   Dali::Property *argp2 ;
39881
39882   arg1 = (Dali::Animation *)jarg1;
39883   argp2 = (Dali::Property *)jarg2;
39884   if (!argp2) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39886     return ;
39887   }
39888   arg2 = *argp2;
39889   arg3 = (Dali::KeyFrames *)jarg3;
39890   if (!arg3) {
39891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39892     return ;
39893   }
39894   {
39895     try {
39896       (arg1)->AnimateBetween(arg2,*arg3);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911 }
39912
39913
39914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39915   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39916   SwigValueWrapper< Dali::Property > arg2 ;
39917   Dali::KeyFrames *arg3 = 0 ;
39918   Dali::Animation::Interpolation arg4 ;
39919   Dali::Property *argp2 ;
39920
39921   arg1 = (Dali::Animation *)jarg1;
39922   argp2 = (Dali::Property *)jarg2;
39923   if (!argp2) {
39924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39925     return ;
39926   }
39927   arg2 = *argp2;
39928   arg3 = (Dali::KeyFrames *)jarg3;
39929   if (!arg3) {
39930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39931     return ;
39932   }
39933   arg4 = (Dali::Animation::Interpolation)jarg4;
39934   {
39935     try {
39936       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39937     } catch (std::out_of_range& e) {
39938       {
39939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39940       };
39941     } catch (std::exception& e) {
39942       {
39943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39944       };
39945     } catch (...) {
39946       {
39947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39948       };
39949     }
39950   }
39951 }
39952
39953
39954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39955   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39956   SwigValueWrapper< Dali::Property > arg2 ;
39957   Dali::KeyFrames *arg3 = 0 ;
39958   Dali::AlphaFunction arg4 ;
39959   Dali::Property *argp2 ;
39960   Dali::AlphaFunction *argp4 ;
39961
39962   arg1 = (Dali::Animation *)jarg1;
39963   argp2 = (Dali::Property *)jarg2;
39964   if (!argp2) {
39965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39966     return ;
39967   }
39968   arg2 = *argp2;
39969   arg3 = (Dali::KeyFrames *)jarg3;
39970   if (!arg3) {
39971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39972     return ;
39973   }
39974   argp4 = (Dali::AlphaFunction *)jarg4;
39975   if (!argp4) {
39976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39977     return ;
39978   }
39979   arg4 = *argp4;
39980   {
39981     try {
39982       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39983     } catch (std::out_of_range& e) {
39984       {
39985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (std::exception& e) {
39988       {
39989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997 }
39998
39999
40000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40001   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40002   SwigValueWrapper< Dali::Property > arg2 ;
40003   Dali::KeyFrames *arg3 = 0 ;
40004   Dali::AlphaFunction arg4 ;
40005   Dali::Animation::Interpolation arg5 ;
40006   Dali::Property *argp2 ;
40007   Dali::AlphaFunction *argp4 ;
40008
40009   arg1 = (Dali::Animation *)jarg1;
40010   argp2 = (Dali::Property *)jarg2;
40011   if (!argp2) {
40012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40013     return ;
40014   }
40015   arg2 = *argp2;
40016   arg3 = (Dali::KeyFrames *)jarg3;
40017   if (!arg3) {
40018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40019     return ;
40020   }
40021   argp4 = (Dali::AlphaFunction *)jarg4;
40022   if (!argp4) {
40023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40024     return ;
40025   }
40026   arg4 = *argp4;
40027   arg5 = (Dali::Animation::Interpolation)jarg5;
40028   {
40029     try {
40030       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40031     } catch (std::out_of_range& e) {
40032       {
40033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40034       };
40035     } catch (std::exception& e) {
40036       {
40037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40042       };
40043     }
40044   }
40045 }
40046
40047
40048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40049   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40050   SwigValueWrapper< Dali::Property > arg2 ;
40051   Dali::KeyFrames *arg3 = 0 ;
40052   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40053   Dali::Property *argp2 ;
40054   Dali::TimePeriod *argp4 ;
40055
40056   arg1 = (Dali::Animation *)jarg1;
40057   argp2 = (Dali::Property *)jarg2;
40058   if (!argp2) {
40059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40060     return ;
40061   }
40062   arg2 = *argp2;
40063   arg3 = (Dali::KeyFrames *)jarg3;
40064   if (!arg3) {
40065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40066     return ;
40067   }
40068   argp4 = (Dali::TimePeriod *)jarg4;
40069   if (!argp4) {
40070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40071     return ;
40072   }
40073   arg4 = *argp4;
40074   {
40075     try {
40076       (arg1)->AnimateBetween(arg2,*arg3,arg4);
40077     } catch (std::out_of_range& e) {
40078       {
40079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40080       };
40081     } catch (std::exception& e) {
40082       {
40083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40084       };
40085     } catch (...) {
40086       {
40087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40088       };
40089     }
40090   }
40091 }
40092
40093
40094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40095   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40096   SwigValueWrapper< Dali::Property > arg2 ;
40097   Dali::KeyFrames *arg3 = 0 ;
40098   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40099   Dali::Animation::Interpolation arg5 ;
40100   Dali::Property *argp2 ;
40101   Dali::TimePeriod *argp4 ;
40102
40103   arg1 = (Dali::Animation *)jarg1;
40104   argp2 = (Dali::Property *)jarg2;
40105   if (!argp2) {
40106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40107     return ;
40108   }
40109   arg2 = *argp2;
40110   arg3 = (Dali::KeyFrames *)jarg3;
40111   if (!arg3) {
40112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40113     return ;
40114   }
40115   argp4 = (Dali::TimePeriod *)jarg4;
40116   if (!argp4) {
40117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40118     return ;
40119   }
40120   arg4 = *argp4;
40121   arg5 = (Dali::Animation::Interpolation)jarg5;
40122   {
40123     try {
40124       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40125     } catch (std::out_of_range& e) {
40126       {
40127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40128       };
40129     } catch (std::exception& e) {
40130       {
40131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40132       };
40133     } catch (...) {
40134       {
40135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40136       };
40137     }
40138   }
40139 }
40140
40141
40142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40143   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40144   SwigValueWrapper< Dali::Property > arg2 ;
40145   Dali::KeyFrames *arg3 = 0 ;
40146   Dali::AlphaFunction arg4 ;
40147   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40148   Dali::Property *argp2 ;
40149   Dali::AlphaFunction *argp4 ;
40150   Dali::TimePeriod *argp5 ;
40151
40152   arg1 = (Dali::Animation *)jarg1;
40153   argp2 = (Dali::Property *)jarg2;
40154   if (!argp2) {
40155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40156     return ;
40157   }
40158   arg2 = *argp2;
40159   arg3 = (Dali::KeyFrames *)jarg3;
40160   if (!arg3) {
40161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40162     return ;
40163   }
40164   argp4 = (Dali::AlphaFunction *)jarg4;
40165   if (!argp4) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40167     return ;
40168   }
40169   arg4 = *argp4;
40170   argp5 = (Dali::TimePeriod *)jarg5;
40171   if (!argp5) {
40172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40173     return ;
40174   }
40175   arg5 = *argp5;
40176   {
40177     try {
40178       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40179     } catch (std::out_of_range& e) {
40180       {
40181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40182       };
40183     } catch (std::exception& e) {
40184       {
40185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40186       };
40187     } catch (...) {
40188       {
40189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40190       };
40191     }
40192   }
40193 }
40194
40195
40196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40197   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40198   SwigValueWrapper< Dali::Property > arg2 ;
40199   Dali::KeyFrames *arg3 = 0 ;
40200   Dali::AlphaFunction arg4 ;
40201   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40202   Dali::Animation::Interpolation arg6 ;
40203   Dali::Property *argp2 ;
40204   Dali::AlphaFunction *argp4 ;
40205   Dali::TimePeriod *argp5 ;
40206
40207   arg1 = (Dali::Animation *)jarg1;
40208   argp2 = (Dali::Property *)jarg2;
40209   if (!argp2) {
40210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40211     return ;
40212   }
40213   arg2 = *argp2;
40214   arg3 = (Dali::KeyFrames *)jarg3;
40215   if (!arg3) {
40216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40217     return ;
40218   }
40219   argp4 = (Dali::AlphaFunction *)jarg4;
40220   if (!argp4) {
40221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40222     return ;
40223   }
40224   arg4 = *argp4;
40225   argp5 = (Dali::TimePeriod *)jarg5;
40226   if (!argp5) {
40227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40228     return ;
40229   }
40230   arg5 = *argp5;
40231   arg6 = (Dali::Animation::Interpolation)jarg6;
40232   {
40233     try {
40234       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40246       };
40247     }
40248   }
40249 }
40250
40251
40252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40253   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40254   Dali::Actor arg2 ;
40255   Dali::Path arg3 ;
40256   Dali::Vector3 *arg4 = 0 ;
40257   Dali::Actor *argp2 ;
40258   Dali::Path *argp3 ;
40259
40260   arg1 = (Dali::Animation *)jarg1;
40261   argp2 = (Dali::Actor *)jarg2;
40262   if (!argp2) {
40263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40264     return ;
40265   }
40266   arg2 = *argp2;
40267   argp3 = (Dali::Path *)jarg3;
40268   if (!argp3) {
40269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40270     return ;
40271   }
40272   arg3 = *argp3;
40273   arg4 = (Dali::Vector3 *)jarg4;
40274   if (!arg4) {
40275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40276     return ;
40277   }
40278   {
40279     try {
40280       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40281     } catch (std::out_of_range& e) {
40282       {
40283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40284       };
40285     } catch (std::exception& e) {
40286       {
40287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40288       };
40289     } catch (...) {
40290       {
40291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40292       };
40293     }
40294   }
40295 }
40296
40297
40298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40299   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40300   Dali::Actor arg2 ;
40301   Dali::Path arg3 ;
40302   Dali::Vector3 *arg4 = 0 ;
40303   Dali::AlphaFunction arg5 ;
40304   Dali::Actor *argp2 ;
40305   Dali::Path *argp3 ;
40306   Dali::AlphaFunction *argp5 ;
40307
40308   arg1 = (Dali::Animation *)jarg1;
40309   argp2 = (Dali::Actor *)jarg2;
40310   if (!argp2) {
40311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40312     return ;
40313   }
40314   arg2 = *argp2;
40315   argp3 = (Dali::Path *)jarg3;
40316   if (!argp3) {
40317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40318     return ;
40319   }
40320   arg3 = *argp3;
40321   arg4 = (Dali::Vector3 *)jarg4;
40322   if (!arg4) {
40323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40324     return ;
40325   }
40326   argp5 = (Dali::AlphaFunction *)jarg5;
40327   if (!argp5) {
40328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40329     return ;
40330   }
40331   arg5 = *argp5;
40332   {
40333     try {
40334       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40335     } catch (std::out_of_range& e) {
40336       {
40337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40338       };
40339     } catch (std::exception& e) {
40340       {
40341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40342       };
40343     } catch (...) {
40344       {
40345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40346       };
40347     }
40348   }
40349 }
40350
40351
40352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40353   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40354   Dali::Actor arg2 ;
40355   Dali::Path arg3 ;
40356   Dali::Vector3 *arg4 = 0 ;
40357   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40358   Dali::Actor *argp2 ;
40359   Dali::Path *argp3 ;
40360   Dali::TimePeriod *argp5 ;
40361
40362   arg1 = (Dali::Animation *)jarg1;
40363   argp2 = (Dali::Actor *)jarg2;
40364   if (!argp2) {
40365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40366     return ;
40367   }
40368   arg2 = *argp2;
40369   argp3 = (Dali::Path *)jarg3;
40370   if (!argp3) {
40371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40372     return ;
40373   }
40374   arg3 = *argp3;
40375   arg4 = (Dali::Vector3 *)jarg4;
40376   if (!arg4) {
40377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40378     return ;
40379   }
40380   argp5 = (Dali::TimePeriod *)jarg5;
40381   if (!argp5) {
40382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40383     return ;
40384   }
40385   arg5 = *argp5;
40386   {
40387     try {
40388       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40389     } catch (std::out_of_range& e) {
40390       {
40391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40392       };
40393     } catch (std::exception& e) {
40394       {
40395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40396       };
40397     } catch (...) {
40398       {
40399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40400       };
40401     }
40402   }
40403 }
40404
40405
40406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40407   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40408   Dali::Actor arg2 ;
40409   Dali::Path arg3 ;
40410   Dali::Vector3 *arg4 = 0 ;
40411   Dali::AlphaFunction arg5 ;
40412   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40413   Dali::Actor *argp2 ;
40414   Dali::Path *argp3 ;
40415   Dali::AlphaFunction *argp5 ;
40416   Dali::TimePeriod *argp6 ;
40417
40418   arg1 = (Dali::Animation *)jarg1;
40419   argp2 = (Dali::Actor *)jarg2;
40420   if (!argp2) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40422     return ;
40423   }
40424   arg2 = *argp2;
40425   argp3 = (Dali::Path *)jarg3;
40426   if (!argp3) {
40427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40428     return ;
40429   }
40430   arg3 = *argp3;
40431   arg4 = (Dali::Vector3 *)jarg4;
40432   if (!arg4) {
40433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40434     return ;
40435   }
40436   argp5 = (Dali::AlphaFunction *)jarg5;
40437   if (!argp5) {
40438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40439     return ;
40440   }
40441   arg5 = *argp5;
40442   argp6 = (Dali::TimePeriod *)jarg6;
40443   if (!argp6) {
40444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40445     return ;
40446   }
40447   arg6 = *argp6;
40448   {
40449     try {
40450       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40451     } catch (std::out_of_range& e) {
40452       {
40453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40454       };
40455     } catch (std::exception& e) {
40456       {
40457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40458       };
40459     } catch (...) {
40460       {
40461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40462       };
40463     }
40464   }
40465 }
40466
40467
40468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40469   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40470   Dali::Actor arg2 ;
40471   float arg3 ;
40472   Dali::Actor *argp2 ;
40473
40474   arg1 = (Dali::Animation *)jarg1;
40475   argp2 = (Dali::Actor *)jarg2;
40476   if (!argp2) {
40477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40478     return ;
40479   }
40480   arg2 = *argp2;
40481   arg3 = (float)jarg3;
40482   {
40483     try {
40484       (arg1)->Show(arg2,arg3);
40485     } catch (std::out_of_range& e) {
40486       {
40487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40488       };
40489     } catch (std::exception& e) {
40490       {
40491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (...) {
40494       {
40495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40496       };
40497     }
40498   }
40499 }
40500
40501
40502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40503   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40504   Dali::Actor arg2 ;
40505   float arg3 ;
40506   Dali::Actor *argp2 ;
40507
40508   arg1 = (Dali::Animation *)jarg1;
40509   argp2 = (Dali::Actor *)jarg2;
40510   if (!argp2) {
40511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40512     return ;
40513   }
40514   arg2 = *argp2;
40515   arg3 = (float)jarg3;
40516   {
40517     try {
40518       (arg1)->Hide(arg2,arg3);
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40526       };
40527     } catch (...) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40530       };
40531     }
40532   }
40533 }
40534
40535
40536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40537   int jresult ;
40538   int result;
40539
40540   result = (int)Dali::LinearConstrainer::Property::VALUE;
40541   jresult = (int)result;
40542   return jresult;
40543 }
40544
40545
40546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40547   int jresult ;
40548   int result;
40549
40550   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40551   jresult = (int)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40557   void * jresult ;
40558   Dali::LinearConstrainer::Property *result = 0 ;
40559
40560   {
40561     try {
40562       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (...) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40574       };
40575     }
40576   }
40577   jresult = (void *)result;
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40583   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40584
40585   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40586   {
40587     try {
40588       delete arg1;
40589     } catch (std::out_of_range& e) {
40590       {
40591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40592       };
40593     } catch (std::exception& e) {
40594       {
40595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40596       };
40597     } catch (...) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40600       };
40601     }
40602   }
40603 }
40604
40605
40606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40607   void * jresult ;
40608   Dali::LinearConstrainer result;
40609
40610   {
40611     try {
40612       result = Dali::LinearConstrainer::New();
40613     } catch (std::out_of_range& e) {
40614       {
40615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40616       };
40617     } catch (std::exception& e) {
40618       {
40619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40620       };
40621     } catch (...) {
40622       {
40623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40624       };
40625     }
40626   }
40627   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40628   return jresult;
40629 }
40630
40631
40632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40633   void * jresult ;
40634   Dali::BaseHandle arg1 ;
40635   Dali::BaseHandle *argp1 ;
40636   Dali::LinearConstrainer result;
40637
40638   argp1 = (Dali::BaseHandle *)jarg1;
40639   if (!argp1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40641     return 0;
40642   }
40643   arg1 = *argp1;
40644   {
40645     try {
40646       result = Dali::LinearConstrainer::DownCast(arg1);
40647     } catch (std::out_of_range& e) {
40648       {
40649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40650       };
40651     } catch (std::exception& e) {
40652       {
40653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40654       };
40655     } catch (...) {
40656       {
40657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40658       };
40659     }
40660   }
40661   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40662   return jresult;
40663 }
40664
40665
40666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40667   void * jresult ;
40668   Dali::LinearConstrainer *result = 0 ;
40669
40670   {
40671     try {
40672       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40673     } catch (std::out_of_range& e) {
40674       {
40675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40676       };
40677     } catch (std::exception& e) {
40678       {
40679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40680       };
40681     } catch (...) {
40682       {
40683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40684       };
40685     }
40686   }
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40693   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40694
40695   arg1 = (Dali::LinearConstrainer *)jarg1;
40696   {
40697     try {
40698       delete arg1;
40699     } catch (std::out_of_range& e) {
40700       {
40701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40702       };
40703     } catch (std::exception& e) {
40704       {
40705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40706       };
40707     } catch (...) {
40708       {
40709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40710       };
40711     }
40712   }
40713 }
40714
40715
40716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40717   void * jresult ;
40718   Dali::LinearConstrainer *arg1 = 0 ;
40719   Dali::LinearConstrainer *result = 0 ;
40720
40721   arg1 = (Dali::LinearConstrainer *)jarg1;
40722   if (!arg1) {
40723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40724     return 0;
40725   }
40726   {
40727     try {
40728       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40729     } catch (std::out_of_range& e) {
40730       {
40731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40732       };
40733     } catch (std::exception& e) {
40734       {
40735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40736       };
40737     } catch (...) {
40738       {
40739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40740       };
40741     }
40742   }
40743   jresult = (void *)result;
40744   return jresult;
40745 }
40746
40747
40748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40749   void * jresult ;
40750   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40751   Dali::LinearConstrainer *arg2 = 0 ;
40752   Dali::LinearConstrainer *result = 0 ;
40753
40754   arg1 = (Dali::LinearConstrainer *)jarg1;
40755   arg2 = (Dali::LinearConstrainer *)jarg2;
40756   if (!arg2) {
40757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40758     return 0;
40759   }
40760   {
40761     try {
40762       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40774       };
40775     }
40776   }
40777   jresult = (void *)result;
40778   return jresult;
40779 }
40780
40781
40782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40783   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40784   SwigValueWrapper< Dali::Property > arg2 ;
40785   SwigValueWrapper< Dali::Property > arg3 ;
40786   Dali::Vector2 *arg4 = 0 ;
40787   Dali::Vector2 *arg5 = 0 ;
40788   Dali::Property *argp2 ;
40789   Dali::Property *argp3 ;
40790
40791   arg1 = (Dali::LinearConstrainer *)jarg1;
40792   argp2 = (Dali::Property *)jarg2;
40793   if (!argp2) {
40794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40795     return ;
40796   }
40797   arg2 = *argp2;
40798   argp3 = (Dali::Property *)jarg3;
40799   if (!argp3) {
40800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40801     return ;
40802   }
40803   arg3 = *argp3;
40804   arg4 = (Dali::Vector2 *)jarg4;
40805   if (!arg4) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40807     return ;
40808   }
40809   arg5 = (Dali::Vector2 *)jarg5;
40810   if (!arg5) {
40811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40812     return ;
40813   }
40814   {
40815     try {
40816       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40817     } catch (std::out_of_range& e) {
40818       {
40819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40820       };
40821     } catch (std::exception& e) {
40822       {
40823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40824       };
40825     } catch (...) {
40826       {
40827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40828       };
40829     }
40830   }
40831 }
40832
40833
40834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40835   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40836   SwigValueWrapper< Dali::Property > arg2 ;
40837   SwigValueWrapper< Dali::Property > arg3 ;
40838   Dali::Vector2 *arg4 = 0 ;
40839   Dali::Property *argp2 ;
40840   Dali::Property *argp3 ;
40841
40842   arg1 = (Dali::LinearConstrainer *)jarg1;
40843   argp2 = (Dali::Property *)jarg2;
40844   if (!argp2) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40846     return ;
40847   }
40848   arg2 = *argp2;
40849   argp3 = (Dali::Property *)jarg3;
40850   if (!argp3) {
40851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40852     return ;
40853   }
40854   arg3 = *argp3;
40855   arg4 = (Dali::Vector2 *)jarg4;
40856   if (!arg4) {
40857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40858     return ;
40859   }
40860   {
40861     try {
40862       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40863     } catch (std::out_of_range& e) {
40864       {
40865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40866       };
40867     } catch (std::exception& e) {
40868       {
40869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40870       };
40871     } catch (...) {
40872       {
40873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40874       };
40875     }
40876   }
40877 }
40878
40879
40880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40881   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40882   Dali::Handle *arg2 = 0 ;
40883
40884   arg1 = (Dali::LinearConstrainer *)jarg1;
40885   arg2 = (Dali::Handle *)jarg2;
40886   if (!arg2) {
40887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40888     return ;
40889   }
40890   {
40891     try {
40892       (arg1)->Remove(*arg2);
40893     } catch (std::out_of_range& e) {
40894       {
40895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (std::exception& e) {
40898       {
40899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40904       };
40905     }
40906   }
40907 }
40908
40909
40910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40911   int jresult ;
40912   int result;
40913
40914   result = (int)Dali::PathConstrainer::Property::FORWARD;
40915   jresult = (int)result;
40916   return jresult;
40917 }
40918
40919
40920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40921   int jresult ;
40922   int result;
40923
40924   result = (int)Dali::PathConstrainer::Property::POINTS;
40925   jresult = (int)result;
40926   return jresult;
40927 }
40928
40929
40930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40931   int jresult ;
40932   int result;
40933
40934   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40935   jresult = (int)result;
40936   return jresult;
40937 }
40938
40939
40940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40941   void * jresult ;
40942   Dali::PathConstrainer::Property *result = 0 ;
40943
40944   {
40945     try {
40946       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40947     } catch (std::out_of_range& e) {
40948       {
40949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40950       };
40951     } catch (std::exception& e) {
40952       {
40953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (...) {
40956       {
40957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40958       };
40959     }
40960   }
40961   jresult = (void *)result;
40962   return jresult;
40963 }
40964
40965
40966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40967   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40968
40969   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40970   {
40971     try {
40972       delete arg1;
40973     } catch (std::out_of_range& e) {
40974       {
40975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40976       };
40977     } catch (std::exception& e) {
40978       {
40979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (...) {
40982       {
40983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40984       };
40985     }
40986   }
40987 }
40988
40989
40990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40991   void * jresult ;
40992   Dali::PathConstrainer result;
40993
40994   {
40995     try {
40996       result = Dali::PathConstrainer::New();
40997     } catch (std::out_of_range& e) {
40998       {
40999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41000       };
41001     } catch (std::exception& e) {
41002       {
41003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41004       };
41005     } catch (...) {
41006       {
41007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41008       };
41009     }
41010   }
41011   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41012   return jresult;
41013 }
41014
41015
41016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
41017   void * jresult ;
41018   Dali::BaseHandle arg1 ;
41019   Dali::BaseHandle *argp1 ;
41020   Dali::PathConstrainer result;
41021
41022   argp1 = (Dali::BaseHandle *)jarg1;
41023   if (!argp1) {
41024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41025     return 0;
41026   }
41027   arg1 = *argp1;
41028   {
41029     try {
41030       result = Dali::PathConstrainer::DownCast(arg1);
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 = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
41046   return jresult;
41047 }
41048
41049
41050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
41051   void * jresult ;
41052   Dali::PathConstrainer *result = 0 ;
41053
41054   {
41055     try {
41056       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
41057     } catch (std::out_of_range& e) {
41058       {
41059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41060       };
41061     } catch (std::exception& e) {
41062       {
41063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41064       };
41065     } catch (...) {
41066       {
41067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41068       };
41069     }
41070   }
41071   jresult = (void *)result;
41072   return jresult;
41073 }
41074
41075
41076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
41077   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41078
41079   arg1 = (Dali::PathConstrainer *)jarg1;
41080   {
41081     try {
41082       delete arg1;
41083     } catch (std::out_of_range& e) {
41084       {
41085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41086       };
41087     } catch (std::exception& e) {
41088       {
41089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (...) {
41092       {
41093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41094       };
41095     }
41096   }
41097 }
41098
41099
41100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41101   void * jresult ;
41102   Dali::PathConstrainer *arg1 = 0 ;
41103   Dali::PathConstrainer *result = 0 ;
41104
41105   arg1 = (Dali::PathConstrainer *)jarg1;
41106   if (!arg1) {
41107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41108     return 0;
41109   }
41110   {
41111     try {
41112       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (...) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41124       };
41125     }
41126   }
41127   jresult = (void *)result;
41128   return jresult;
41129 }
41130
41131
41132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41133   void * jresult ;
41134   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41135   Dali::PathConstrainer *arg2 = 0 ;
41136   Dali::PathConstrainer *result = 0 ;
41137
41138   arg1 = (Dali::PathConstrainer *)jarg1;
41139   arg2 = (Dali::PathConstrainer *)jarg2;
41140   if (!arg2) {
41141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41142     return 0;
41143   }
41144   {
41145     try {
41146       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41147     } catch (std::out_of_range& e) {
41148       {
41149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (std::exception& e) {
41152       {
41153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41158       };
41159     }
41160   }
41161   jresult = (void *)result;
41162   return jresult;
41163 }
41164
41165
41166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41167   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41168   SwigValueWrapper< Dali::Property > arg2 ;
41169   SwigValueWrapper< Dali::Property > arg3 ;
41170   Dali::Vector2 *arg4 = 0 ;
41171   Dali::Vector2 *arg5 = 0 ;
41172   Dali::Property *argp2 ;
41173   Dali::Property *argp3 ;
41174
41175   arg1 = (Dali::PathConstrainer *)jarg1;
41176   argp2 = (Dali::Property *)jarg2;
41177   if (!argp2) {
41178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41179     return ;
41180   }
41181   arg2 = *argp2;
41182   argp3 = (Dali::Property *)jarg3;
41183   if (!argp3) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41185     return ;
41186   }
41187   arg3 = *argp3;
41188   arg4 = (Dali::Vector2 *)jarg4;
41189   if (!arg4) {
41190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41191     return ;
41192   }
41193   arg5 = (Dali::Vector2 *)jarg5;
41194   if (!arg5) {
41195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41196     return ;
41197   }
41198   {
41199     try {
41200       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41201     } catch (std::out_of_range& e) {
41202       {
41203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41204       };
41205     } catch (std::exception& e) {
41206       {
41207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41212       };
41213     }
41214   }
41215 }
41216
41217
41218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41219   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41220   SwigValueWrapper< Dali::Property > arg2 ;
41221   SwigValueWrapper< Dali::Property > arg3 ;
41222   Dali::Vector2 *arg4 = 0 ;
41223   Dali::Property *argp2 ;
41224   Dali::Property *argp3 ;
41225
41226   arg1 = (Dali::PathConstrainer *)jarg1;
41227   argp2 = (Dali::Property *)jarg2;
41228   if (!argp2) {
41229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41230     return ;
41231   }
41232   arg2 = *argp2;
41233   argp3 = (Dali::Property *)jarg3;
41234   if (!argp3) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41236     return ;
41237   }
41238   arg3 = *argp3;
41239   arg4 = (Dali::Vector2 *)jarg4;
41240   if (!arg4) {
41241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41242     return ;
41243   }
41244   {
41245     try {
41246       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41247     } catch (std::out_of_range& e) {
41248       {
41249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41250       };
41251     } catch (std::exception& e) {
41252       {
41253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41254       };
41255     } catch (...) {
41256       {
41257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41258       };
41259     }
41260   }
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41265   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41266   Dali::Handle *arg2 = 0 ;
41267
41268   arg1 = (Dali::PathConstrainer *)jarg1;
41269   arg2 = (Dali::Handle *)jarg2;
41270   if (!arg2) {
41271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41272     return ;
41273   }
41274   {
41275     try {
41276       (arg1)->Remove(*arg2);
41277     } catch (std::out_of_range& e) {
41278       {
41279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41280       };
41281     } catch (std::exception& e) {
41282       {
41283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41284       };
41285     } catch (...) {
41286       {
41287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41288       };
41289     }
41290   }
41291 }
41292
41293
41294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41295   int jresult ;
41296   Dali::FittingMode::Type result;
41297
41298   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41299   jresult = (int)result;
41300   return jresult;
41301 }
41302
41303
41304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41305   int jresult ;
41306   Dali::SamplingMode::Type result;
41307
41308   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41309   jresult = (int)result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41315   void * jresult ;
41316   Dali::BufferImage *result = 0 ;
41317
41318   {
41319     try {
41320       result = (Dali::BufferImage *)new Dali::BufferImage();
41321     } catch (std::out_of_range& e) {
41322       {
41323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41324       };
41325     } catch (std::exception& e) {
41326       {
41327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41328       };
41329     } catch (...) {
41330       {
41331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41332       };
41333     }
41334   }
41335   jresult = (void *)result;
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41341   void * jresult ;
41342   unsigned int arg1 ;
41343   unsigned int arg2 ;
41344   Dali::Pixel::Format arg3 ;
41345   Dali::BufferImage result;
41346
41347   arg1 = (unsigned int)jarg1;
41348   arg2 = (unsigned int)jarg2;
41349   arg3 = (Dali::Pixel::Format)jarg3;
41350   {
41351     try {
41352       result = Dali::BufferImage::New(arg1,arg2,arg3);
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (...) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41364       };
41365     }
41366   }
41367   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41373   void * jresult ;
41374   unsigned int arg1 ;
41375   unsigned int arg2 ;
41376   Dali::BufferImage result;
41377
41378   arg1 = (unsigned int)jarg1;
41379   arg2 = (unsigned int)jarg2;
41380   {
41381     try {
41382       result = Dali::BufferImage::New(arg1,arg2);
41383     } catch (std::out_of_range& e) {
41384       {
41385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (std::exception& e) {
41388       {
41389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41403   void * jresult ;
41404   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41405   unsigned int arg2 ;
41406   unsigned int arg3 ;
41407   Dali::Pixel::Format arg4 ;
41408   unsigned int arg5 ;
41409   Dali::BufferImage result;
41410
41411   arg1 = jarg1;
41412   arg2 = (unsigned int)jarg2;
41413   arg3 = (unsigned int)jarg3;
41414   arg4 = (Dali::Pixel::Format)jarg4;
41415   arg5 = (unsigned int)jarg5;
41416   {
41417     try {
41418       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41419     } catch (std::out_of_range& e) {
41420       {
41421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41422       };
41423     } catch (std::exception& e) {
41424       {
41425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (...) {
41428       {
41429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41430       };
41431     }
41432   }
41433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41434
41435
41436   return jresult;
41437 }
41438
41439
41440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41441   void * jresult ;
41442   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41443   unsigned int arg2 ;
41444   unsigned int arg3 ;
41445   Dali::Pixel::Format arg4 ;
41446   Dali::BufferImage result;
41447
41448   arg1 = jarg1;
41449   arg2 = (unsigned int)jarg2;
41450   arg3 = (unsigned int)jarg3;
41451   arg4 = (Dali::Pixel::Format)jarg4;
41452   {
41453     try {
41454       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41455     } catch (std::out_of_range& e) {
41456       {
41457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41458       };
41459     } catch (std::exception& e) {
41460       {
41461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41462       };
41463     } catch (...) {
41464       {
41465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41466       };
41467     }
41468   }
41469   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41470
41471
41472   return jresult;
41473 }
41474
41475
41476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41477   void * jresult ;
41478   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41479   unsigned int arg2 ;
41480   unsigned int arg3 ;
41481   Dali::BufferImage result;
41482
41483   arg1 = jarg1;
41484   arg2 = (unsigned int)jarg2;
41485   arg3 = (unsigned int)jarg3;
41486   {
41487     try {
41488       result = Dali::BufferImage::New(arg1,arg2,arg3);
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 = new Dali::BufferImage((const Dali::BufferImage &)result);
41504
41505
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41511   void * jresult ;
41512   Dali::BaseHandle arg1 ;
41513   Dali::BaseHandle *argp1 ;
41514   Dali::BufferImage result;
41515
41516   argp1 = (Dali::BaseHandle *)jarg1;
41517   if (!argp1) {
41518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41519     return 0;
41520   }
41521   arg1 = *argp1;
41522   {
41523     try {
41524       result = Dali::BufferImage::DownCast(arg1);
41525     } catch (std::out_of_range& e) {
41526       {
41527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (std::exception& e) {
41530       {
41531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41532       };
41533     } catch (...) {
41534       {
41535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41536       };
41537     }
41538   }
41539   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41540   return jresult;
41541 }
41542
41543
41544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41545   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41546
41547   arg1 = (Dali::BufferImage *)jarg1;
41548   {
41549     try {
41550       delete arg1;
41551     } catch (std::out_of_range& e) {
41552       {
41553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41554       };
41555     } catch (std::exception& e) {
41556       {
41557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41558       };
41559     } catch (...) {
41560       {
41561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41562       };
41563     }
41564   }
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41569   void * jresult ;
41570   Dali::BufferImage *arg1 = 0 ;
41571   Dali::BufferImage *result = 0 ;
41572
41573   arg1 = (Dali::BufferImage *)jarg1;
41574   if (!arg1) {
41575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41576     return 0;
41577   }
41578   {
41579     try {
41580       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41581     } catch (std::out_of_range& e) {
41582       {
41583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (std::exception& e) {
41586       {
41587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41588       };
41589     } catch (...) {
41590       {
41591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41592       };
41593     }
41594   }
41595   jresult = (void *)result;
41596   return jresult;
41597 }
41598
41599
41600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41601   void * jresult ;
41602   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41603   Dali::BufferImage *arg2 = 0 ;
41604   Dali::BufferImage *result = 0 ;
41605
41606   arg1 = (Dali::BufferImage *)jarg1;
41607   arg2 = (Dali::BufferImage *)jarg2;
41608   if (!arg2) {
41609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41610     return 0;
41611   }
41612   {
41613     try {
41614       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41615     } catch (std::out_of_range& e) {
41616       {
41617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41618       };
41619     } catch (std::exception& e) {
41620       {
41621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41622       };
41623     } catch (...) {
41624       {
41625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41626       };
41627     }
41628   }
41629   jresult = (void *)result;
41630   return jresult;
41631 }
41632
41633
41634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41635   void * jresult ;
41636   Dali::BufferImage result;
41637
41638   {
41639     try {
41640       result = Dali::BufferImage::WHITE();
41641     } catch (std::out_of_range& e) {
41642       {
41643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41644       };
41645     } catch (std::exception& e) {
41646       {
41647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41648       };
41649     } catch (...) {
41650       {
41651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41652       };
41653     }
41654   }
41655   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41661   void * jresult ;
41662   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41663   Dali::PixelBuffer *result = 0 ;
41664
41665   arg1 = (Dali::BufferImage *)jarg1;
41666   {
41667     try {
41668       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41669     } catch (std::out_of_range& e) {
41670       {
41671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (std::exception& e) {
41674       {
41675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41676       };
41677     } catch (...) {
41678       {
41679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41680       };
41681     }
41682   }
41683   jresult = (void *)result;
41684   return jresult;
41685 }
41686
41687
41688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41689   unsigned int jresult ;
41690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41691   unsigned int result;
41692
41693   arg1 = (Dali::BufferImage *)jarg1;
41694   {
41695     try {
41696       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41697     } catch (std::out_of_range& e) {
41698       {
41699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (std::exception& e) {
41702       {
41703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41704       };
41705     } catch (...) {
41706       {
41707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41708       };
41709     }
41710   }
41711   jresult = result;
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41717   unsigned int jresult ;
41718   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41719   unsigned int result;
41720
41721   arg1 = (Dali::BufferImage *)jarg1;
41722   {
41723     try {
41724       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (...) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41736       };
41737     }
41738   }
41739   jresult = result;
41740   return jresult;
41741 }
41742
41743
41744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41745   int jresult ;
41746   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41747   Dali::Pixel::Format result;
41748
41749   arg1 = (Dali::BufferImage *)jarg1;
41750   {
41751     try {
41752       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (...) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41764       };
41765     }
41766   }
41767   jresult = (int)result;
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41773   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41774
41775   arg1 = (Dali::BufferImage *)jarg1;
41776   {
41777     try {
41778       (arg1)->Update();
41779     } catch (std::out_of_range& e) {
41780       {
41781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41782       };
41783     } catch (std::exception& e) {
41784       {
41785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41786       };
41787     } catch (...) {
41788       {
41789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41790       };
41791     }
41792   }
41793 }
41794
41795
41796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41797   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41798   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41799   Dali::RectArea *argp2 ;
41800
41801   arg1 = (Dali::BufferImage *)jarg1;
41802   argp2 = (Dali::RectArea *)jarg2;
41803   if (!argp2) {
41804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41805     return ;
41806   }
41807   arg2 = *argp2;
41808   {
41809     try {
41810       (arg1)->Update(arg2);
41811     } catch (std::out_of_range& e) {
41812       {
41813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41814       };
41815     } catch (std::exception& e) {
41816       {
41817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41818       };
41819     } catch (...) {
41820       {
41821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41822       };
41823     }
41824   }
41825 }
41826
41827
41828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41829   unsigned int jresult ;
41830   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41831   bool result;
41832
41833   arg1 = (Dali::BufferImage *)jarg1;
41834   {
41835     try {
41836       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (...) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41848       };
41849     }
41850   }
41851   jresult = result;
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41857   void * jresult ;
41858   Dali::EncodedBufferImage *result = 0 ;
41859
41860   {
41861     try {
41862       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41863     } catch (std::out_of_range& e) {
41864       {
41865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (std::exception& e) {
41868       {
41869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41883   void * jresult ;
41884   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41885   std::size_t arg2 ;
41886   Dali::EncodedBufferImage result;
41887
41888   arg1 = (uint8_t *)jarg1;
41889   arg2 = (std::size_t)jarg2;
41890   {
41891     try {
41892       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (...) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41904       };
41905     }
41906   }
41907   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41913   void * jresult ;
41914   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41915   std::size_t arg2 ;
41916   Dali::ImageDimensions arg3 ;
41917   Dali::FittingMode::Type arg4 ;
41918   Dali::SamplingMode::Type arg5 ;
41919   bool arg6 ;
41920   Dali::ImageDimensions *argp3 ;
41921   Dali::EncodedBufferImage result;
41922
41923   arg1 = (uint8_t *)jarg1;
41924   arg2 = (std::size_t)jarg2;
41925   argp3 = (Dali::ImageDimensions *)jarg3;
41926   if (!argp3) {
41927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41928     return 0;
41929   }
41930   arg3 = *argp3;
41931   arg4 = (Dali::FittingMode::Type)jarg4;
41932   arg5 = (Dali::SamplingMode::Type)jarg5;
41933   arg6 = jarg6 ? true : false;
41934   {
41935     try {
41936       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41937     } catch (std::out_of_range& e) {
41938       {
41939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (std::exception& e) {
41942       {
41943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (...) {
41946       {
41947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41948       };
41949     }
41950   }
41951   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41952   return jresult;
41953 }
41954
41955
41956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41957   void * jresult ;
41958   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41959   std::size_t arg2 ;
41960   Dali::ImageDimensions arg3 ;
41961   Dali::FittingMode::Type arg4 ;
41962   Dali::SamplingMode::Type arg5 ;
41963   Dali::ImageDimensions *argp3 ;
41964   Dali::EncodedBufferImage result;
41965
41966   arg1 = (uint8_t *)jarg1;
41967   arg2 = (std::size_t)jarg2;
41968   argp3 = (Dali::ImageDimensions *)jarg3;
41969   if (!argp3) {
41970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41971     return 0;
41972   }
41973   arg3 = *argp3;
41974   arg4 = (Dali::FittingMode::Type)jarg4;
41975   arg5 = (Dali::SamplingMode::Type)jarg5;
41976   {
41977     try {
41978       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41979     } catch (std::out_of_range& e) {
41980       {
41981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41982       };
41983     } catch (std::exception& e) {
41984       {
41985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41986       };
41987     } catch (...) {
41988       {
41989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41990       };
41991     }
41992   }
41993   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41994   return jresult;
41995 }
41996
41997
41998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41999   void * jresult ;
42000   Dali::BaseHandle arg1 ;
42001   Dali::BaseHandle *argp1 ;
42002   Dali::EncodedBufferImage result;
42003
42004   argp1 = (Dali::BaseHandle *)jarg1;
42005   if (!argp1) {
42006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42007     return 0;
42008   }
42009   arg1 = *argp1;
42010   {
42011     try {
42012       result = Dali::EncodedBufferImage::DownCast(arg1);
42013     } catch (std::out_of_range& e) {
42014       {
42015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (std::exception& e) {
42018       {
42019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
42033   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42034
42035   arg1 = (Dali::EncodedBufferImage *)jarg1;
42036   {
42037     try {
42038       delete arg1;
42039     } catch (std::out_of_range& e) {
42040       {
42041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42042       };
42043     } catch (std::exception& e) {
42044       {
42045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42046       };
42047     } catch (...) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42050       };
42051     }
42052   }
42053 }
42054
42055
42056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
42057   void * jresult ;
42058   Dali::EncodedBufferImage *arg1 = 0 ;
42059   Dali::EncodedBufferImage *result = 0 ;
42060
42061   arg1 = (Dali::EncodedBufferImage *)jarg1;
42062   if (!arg1) {
42063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42064     return 0;
42065   }
42066   {
42067     try {
42068       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
42069     } catch (std::out_of_range& e) {
42070       {
42071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42072       };
42073     } catch (std::exception& e) {
42074       {
42075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42080       };
42081     }
42082   }
42083   jresult = (void *)result;
42084   return jresult;
42085 }
42086
42087
42088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42089   void * jresult ;
42090   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42091   Dali::EncodedBufferImage *arg2 = 0 ;
42092   Dali::EncodedBufferImage *result = 0 ;
42093
42094   arg1 = (Dali::EncodedBufferImage *)jarg1;
42095   arg2 = (Dali::EncodedBufferImage *)jarg2;
42096   if (!arg2) {
42097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42098     return 0;
42099   }
42100   {
42101     try {
42102       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42103     } catch (std::out_of_range& e) {
42104       {
42105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42106       };
42107     } catch (std::exception& e) {
42108       {
42109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42110       };
42111     } catch (...) {
42112       {
42113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42114       };
42115     }
42116   }
42117   jresult = (void *)result;
42118   return jresult;
42119 }
42120
42121
42122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42123   void * jresult ;
42124   Dali::NativeImage *result = 0 ;
42125
42126   {
42127     try {
42128       result = (Dali::NativeImage *)new Dali::NativeImage();
42129     } catch (std::out_of_range& e) {
42130       {
42131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (std::exception& e) {
42134       {
42135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42136       };
42137     } catch (...) {
42138       {
42139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42140       };
42141     }
42142   }
42143   jresult = (void *)result;
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42149   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42150
42151   arg1 = (Dali::NativeImage *)jarg1;
42152   {
42153     try {
42154       delete arg1;
42155     } catch (std::out_of_range& e) {
42156       {
42157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42158       };
42159     } catch (std::exception& e) {
42160       {
42161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42162       };
42163     } catch (...) {
42164       {
42165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42166       };
42167     }
42168   }
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42173   void * jresult ;
42174   Dali::NativeImage *arg1 = 0 ;
42175   Dali::NativeImage *result = 0 ;
42176
42177   arg1 = (Dali::NativeImage *)jarg1;
42178   if (!arg1) {
42179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42180     return 0;
42181   }
42182   {
42183     try {
42184       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42185     } catch (std::out_of_range& e) {
42186       {
42187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42188       };
42189     } catch (std::exception& e) {
42190       {
42191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42192       };
42193     } catch (...) {
42194       {
42195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42196       };
42197     }
42198   }
42199   jresult = (void *)result;
42200   return jresult;
42201 }
42202
42203
42204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42205   void * jresult ;
42206   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42207   Dali::NativeImage *arg2 = 0 ;
42208   Dali::NativeImage *result = 0 ;
42209
42210   arg1 = (Dali::NativeImage *)jarg1;
42211   arg2 = (Dali::NativeImage *)jarg2;
42212   if (!arg2) {
42213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42214     return 0;
42215   }
42216   {
42217     try {
42218       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42219     } catch (std::out_of_range& e) {
42220       {
42221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42222       };
42223     } catch (std::exception& e) {
42224       {
42225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42226       };
42227     } catch (...) {
42228       {
42229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42230       };
42231     }
42232   }
42233   jresult = (void *)result;
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42239   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42240
42241   arg1 = (Dali::NativeImage *)jarg1;
42242   {
42243     try {
42244       (arg1)->CreateGlTexture();
42245     } catch (std::out_of_range& e) {
42246       {
42247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42248       };
42249     } catch (std::exception& e) {
42250       {
42251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42252       };
42253     } catch (...) {
42254       {
42255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42256       };
42257     }
42258   }
42259 }
42260
42261
42262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42263   void * jresult ;
42264   NativeImageInterface *arg1 = 0 ;
42265   Dali::NativeImage result;
42266
42267   arg1 = (NativeImageInterface *)jarg1;
42268   if (!arg1) {
42269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42270     return 0;
42271   }
42272   {
42273     try {
42274       result = Dali::NativeImage::New(*arg1);
42275     } catch (std::out_of_range& e) {
42276       {
42277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42278       };
42279     } catch (std::exception& e) {
42280       {
42281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42282       };
42283     } catch (...) {
42284       {
42285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42286       };
42287     }
42288   }
42289   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42290   return jresult;
42291 }
42292
42293
42294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42295   void * jresult ;
42296   Dali::BaseHandle arg1 ;
42297   Dali::BaseHandle *argp1 ;
42298   Dali::NativeImage result;
42299
42300   argp1 = (Dali::BaseHandle *)jarg1;
42301   if (!argp1) {
42302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42303     return 0;
42304   }
42305   arg1 = *argp1;
42306   {
42307     try {
42308       result = Dali::NativeImage::DownCast(arg1);
42309     } catch (std::out_of_range& e) {
42310       {
42311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42312       };
42313     } catch (std::exception& e) {
42314       {
42315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (...) {
42318       {
42319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42320       };
42321     }
42322   }
42323   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42329   char * jresult ;
42330   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42331   char *result = 0 ;
42332
42333   arg1 = (Dali::NativeImage *)jarg1;
42334   {
42335     try {
42336       result = (char *)(arg1)->GetCustomFragmentPreFix();
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (...) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42348       };
42349     }
42350   }
42351   jresult = SWIG_csharp_string_callback((const char *)result);
42352   return jresult;
42353 }
42354
42355
42356 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42357   char * jresult ;
42358   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42359   char *result = 0 ;
42360
42361   arg1 = (Dali::NativeImage *)jarg1;
42362   {
42363     try {
42364       result = (char *)(arg1)->GetCustomSamplerTypename();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = SWIG_csharp_string_callback((const char *)result);
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42385   unsigned int jresult ;
42386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42387   bool result;
42388
42389   arg1 = (Dali::NativeImageInterface *)jarg1;
42390   {
42391     try {
42392       result = (bool)(arg1)->GlExtensionCreate();
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42404       };
42405     }
42406   }
42407   jresult = result;
42408   return jresult;
42409 }
42410
42411
42412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42413   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42414
42415   arg1 = (Dali::NativeImageInterface *)jarg1;
42416   {
42417     try {
42418       (arg1)->GlExtensionDestroy();
42419     } catch (std::out_of_range& e) {
42420       {
42421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42422       };
42423     } catch (std::exception& e) {
42424       {
42425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42430       };
42431     }
42432   }
42433 }
42434
42435
42436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42437   unsigned int jresult ;
42438   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42439   unsigned int result;
42440
42441   arg1 = (Dali::NativeImageInterface *)jarg1;
42442   {
42443     try {
42444       result = (unsigned int)(arg1)->TargetTexture();
42445     } catch (std::out_of_range& e) {
42446       {
42447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42448       };
42449     } catch (std::exception& e) {
42450       {
42451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (...) {
42454       {
42455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42456       };
42457     }
42458   }
42459   jresult = result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42465   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42466
42467   arg1 = (Dali::NativeImageInterface *)jarg1;
42468   {
42469     try {
42470       (arg1)->PrepareTexture();
42471     } catch (std::out_of_range& e) {
42472       {
42473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42474       };
42475     } catch (std::exception& e) {
42476       {
42477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (...) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42482       };
42483     }
42484   }
42485 }
42486
42487
42488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42489   unsigned int jresult ;
42490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42491   unsigned int result;
42492
42493   arg1 = (Dali::NativeImageInterface *)jarg1;
42494   {
42495     try {
42496       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42497     } catch (std::out_of_range& e) {
42498       {
42499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (std::exception& e) {
42502       {
42503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42508       };
42509     }
42510   }
42511   jresult = result;
42512   return jresult;
42513 }
42514
42515
42516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42517   unsigned int jresult ;
42518   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42519   unsigned int result;
42520
42521   arg1 = (Dali::NativeImageInterface *)jarg1;
42522   {
42523     try {
42524       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42525     } catch (std::out_of_range& e) {
42526       {
42527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (std::exception& e) {
42530       {
42531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42532       };
42533     } catch (...) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42536       };
42537     }
42538   }
42539   jresult = result;
42540   return jresult;
42541 }
42542
42543
42544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42545   unsigned int jresult ;
42546   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42547   bool result;
42548
42549   arg1 = (Dali::NativeImageInterface *)jarg1;
42550   {
42551     try {
42552       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42553     } catch (std::out_of_range& e) {
42554       {
42555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42556       };
42557     } catch (std::exception& e) {
42558       {
42559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42560       };
42561     } catch (...) {
42562       {
42563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42564       };
42565     }
42566   }
42567   jresult = result;
42568   return jresult;
42569 }
42570
42571
42572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42573   void * jresult ;
42574   std::string *arg1 = 0 ;
42575   Dali::ImageDimensions result;
42576
42577   if (!jarg1) {
42578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42579     return 0;
42580   }
42581   std::string arg1_str(jarg1);
42582   arg1 = &arg1_str;
42583   {
42584     try {
42585       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42586     } catch (std::out_of_range& e) {
42587       {
42588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (std::exception& e) {
42591       {
42592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42601
42602   //argout typemap for const std::string&
42603
42604   return jresult;
42605 }
42606
42607
42608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42609   void * jresult ;
42610   Dali::ResourceImage *result = 0 ;
42611
42612   {
42613     try {
42614       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42615     } catch (std::out_of_range& e) {
42616       {
42617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42618       };
42619     } catch (std::exception& e) {
42620       {
42621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (...) {
42624       {
42625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42626       };
42627     }
42628   }
42629   jresult = (void *)result;
42630   return jresult;
42631 }
42632
42633
42634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42635   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42636
42637   arg1 = (Dali::ResourceImage *)jarg1;
42638   {
42639     try {
42640       delete arg1;
42641     } catch (std::out_of_range& e) {
42642       {
42643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42644       };
42645     } catch (std::exception& e) {
42646       {
42647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42648       };
42649     } catch (...) {
42650       {
42651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42652       };
42653     }
42654   }
42655 }
42656
42657
42658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42659   void * jresult ;
42660   Dali::ResourceImage *arg1 = 0 ;
42661   Dali::ResourceImage *result = 0 ;
42662
42663   arg1 = (Dali::ResourceImage *)jarg1;
42664   if (!arg1) {
42665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42666     return 0;
42667   }
42668   {
42669     try {
42670       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42671     } catch (std::out_of_range& e) {
42672       {
42673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (std::exception& e) {
42676       {
42677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42691   void * jresult ;
42692   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42693   Dali::ResourceImage *arg2 = 0 ;
42694   Dali::ResourceImage *result = 0 ;
42695
42696   arg1 = (Dali::ResourceImage *)jarg1;
42697   arg2 = (Dali::ResourceImage *)jarg2;
42698   if (!arg2) {
42699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42700     return 0;
42701   }
42702   {
42703     try {
42704       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42705     } catch (std::out_of_range& e) {
42706       {
42707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42708       };
42709     } catch (std::exception& e) {
42710       {
42711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42712       };
42713     } catch (...) {
42714       {
42715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42716       };
42717     }
42718   }
42719   jresult = (void *)result;
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42725   void * jresult ;
42726   std::string *arg1 = 0 ;
42727   bool arg2 ;
42728   Dali::ResourceImage result;
42729
42730   if (!jarg1) {
42731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42732     return 0;
42733   }
42734   std::string arg1_str(jarg1);
42735   arg1 = &arg1_str;
42736   arg2 = jarg2 ? true : false;
42737   {
42738     try {
42739       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42755
42756   //argout typemap for const std::string&
42757
42758   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42763   void * jresult ;
42764   std::string *arg1 = 0 ;
42765   Dali::ResourceImage result;
42766
42767   if (!jarg1) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42769     return 0;
42770   }
42771   std::string arg1_str(jarg1);
42772   arg1 = &arg1_str;
42773   {
42774     try {
42775       result = Dali::ResourceImage::New((std::string const &)*arg1);
42776     } catch (std::out_of_range& e) {
42777       {
42778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42779       };
42780     } catch (std::exception& e) {
42781       {
42782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (...) {
42785       {
42786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42787       };
42788     }
42789   }
42790   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42791
42792   //argout typemap for const std::string&
42793
42794   return jresult;
42795 }
42796
42797
42798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42799   void * jresult ;
42800   std::string *arg1 = 0 ;
42801   Dali::ImageDimensions arg2 ;
42802   Dali::FittingMode::Type arg3 ;
42803   Dali::SamplingMode::Type arg4 ;
42804   bool arg5 ;
42805   Dali::ImageDimensions *argp2 ;
42806   Dali::ResourceImage result;
42807
42808   if (!jarg1) {
42809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42810     return 0;
42811   }
42812   std::string arg1_str(jarg1);
42813   arg1 = &arg1_str;
42814   argp2 = (Dali::ImageDimensions *)jarg2;
42815   if (!argp2) {
42816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42817     return 0;
42818   }
42819   arg2 = *argp2;
42820   arg3 = (Dali::FittingMode::Type)jarg3;
42821   arg4 = (Dali::SamplingMode::Type)jarg4;
42822   arg5 = jarg5 ? true : false;
42823   {
42824     try {
42825       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (...) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42837       };
42838     }
42839   }
42840   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42841
42842   //argout typemap for const std::string&
42843
42844   return jresult;
42845 }
42846
42847
42848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42849   void * jresult ;
42850   std::string *arg1 = 0 ;
42851   Dali::ImageDimensions arg2 ;
42852   Dali::FittingMode::Type arg3 ;
42853   Dali::SamplingMode::Type arg4 ;
42854   Dali::ImageDimensions *argp2 ;
42855   Dali::ResourceImage result;
42856
42857   if (!jarg1) {
42858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42859     return 0;
42860   }
42861   std::string arg1_str(jarg1);
42862   arg1 = &arg1_str;
42863   argp2 = (Dali::ImageDimensions *)jarg2;
42864   if (!argp2) {
42865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42866     return 0;
42867   }
42868   arg2 = *argp2;
42869   arg3 = (Dali::FittingMode::Type)jarg3;
42870   arg4 = (Dali::SamplingMode::Type)jarg4;
42871   {
42872     try {
42873       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42874     } catch (std::out_of_range& e) {
42875       {
42876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42877       };
42878     } catch (std::exception& e) {
42879       {
42880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42881       };
42882     } catch (...) {
42883       {
42884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42885       };
42886     }
42887   }
42888   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42889
42890   //argout typemap for const std::string&
42891
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42897   void * jresult ;
42898   std::string *arg1 = 0 ;
42899   Dali::ImageDimensions arg2 ;
42900   Dali::FittingMode::Type arg3 ;
42901   Dali::ImageDimensions *argp2 ;
42902   Dali::ResourceImage result;
42903
42904   if (!jarg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42906     return 0;
42907   }
42908   std::string arg1_str(jarg1);
42909   arg1 = &arg1_str;
42910   argp2 = (Dali::ImageDimensions *)jarg2;
42911   if (!argp2) {
42912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42913     return 0;
42914   }
42915   arg2 = *argp2;
42916   arg3 = (Dali::FittingMode::Type)jarg3;
42917   {
42918     try {
42919       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42920     } catch (std::out_of_range& e) {
42921       {
42922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42923       };
42924     } catch (std::exception& e) {
42925       {
42926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (...) {
42929       {
42930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42931       };
42932     }
42933   }
42934   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42935
42936   //argout typemap for const std::string&
42937
42938   return jresult;
42939 }
42940
42941
42942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42943   void * jresult ;
42944   std::string *arg1 = 0 ;
42945   Dali::ImageDimensions arg2 ;
42946   Dali::ImageDimensions *argp2 ;
42947   Dali::ResourceImage result;
42948
42949   if (!jarg1) {
42950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42951     return 0;
42952   }
42953   std::string arg1_str(jarg1);
42954   arg1 = &arg1_str;
42955   argp2 = (Dali::ImageDimensions *)jarg2;
42956   if (!argp2) {
42957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42958     return 0;
42959   }
42960   arg2 = *argp2;
42961   {
42962     try {
42963       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42964     } catch (std::out_of_range& e) {
42965       {
42966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42967       };
42968     } catch (std::exception& e) {
42969       {
42970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42971       };
42972     } catch (...) {
42973       {
42974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42975       };
42976     }
42977   }
42978   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42979
42980   //argout typemap for const std::string&
42981
42982   return jresult;
42983 }
42984
42985
42986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42987   void * jresult ;
42988   Dali::BaseHandle arg1 ;
42989   Dali::BaseHandle *argp1 ;
42990   Dali::ResourceImage result;
42991
42992   argp1 = (Dali::BaseHandle *)jarg1;
42993   if (!argp1) {
42994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42995     return 0;
42996   }
42997   arg1 = *argp1;
42998   {
42999     try {
43000       result = Dali::ResourceImage::DownCast(arg1);
43001     } catch (std::out_of_range& e) {
43002       {
43003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (std::exception& e) {
43006       {
43007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43008       };
43009     } catch (...) {
43010       {
43011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43012       };
43013     }
43014   }
43015   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
43016   return jresult;
43017 }
43018
43019
43020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
43021   int jresult ;
43022   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43023   Dali::LoadingState result;
43024
43025   arg1 = (Dali::ResourceImage *)jarg1;
43026   {
43027     try {
43028       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
43029     } catch (std::out_of_range& e) {
43030       {
43031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43032       };
43033     } catch (std::exception& e) {
43034       {
43035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43036       };
43037     } catch (...) {
43038       {
43039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43040       };
43041     }
43042   }
43043   jresult = (int)result;
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
43049   char * jresult ;
43050   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43051   std::string result;
43052
43053   arg1 = (Dali::ResourceImage *)jarg1;
43054   {
43055     try {
43056       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43068       };
43069     }
43070   }
43071   jresult = SWIG_csharp_string_callback((&result)->c_str());
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
43077   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43078
43079   arg1 = (Dali::ResourceImage *)jarg1;
43080   {
43081     try {
43082       (arg1)->Reload();
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (...) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43094       };
43095     }
43096   }
43097 }
43098
43099
43100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43101   void * jresult ;
43102   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43103   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43104
43105   arg1 = (Dali::ResourceImage *)jarg1;
43106   {
43107     try {
43108       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43109     } catch (std::out_of_range& e) {
43110       {
43111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (std::exception& e) {
43114       {
43115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43120       };
43121     }
43122   }
43123   jresult = (void *)result;
43124   return jresult;
43125 }
43126
43127
43128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43129   void * jresult ;
43130   Dali::FrameBufferImage *result = 0 ;
43131
43132   {
43133     try {
43134       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43135     } catch (std::out_of_range& e) {
43136       {
43137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43138       };
43139     } catch (std::exception& e) {
43140       {
43141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43142       };
43143     } catch (...) {
43144       {
43145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43146       };
43147     }
43148   }
43149   jresult = (void *)result;
43150   return jresult;
43151 }
43152
43153
43154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43155   void * jresult ;
43156   unsigned int arg1 ;
43157   unsigned int arg2 ;
43158   Dali::Pixel::Format arg3 ;
43159   Dali::RenderBuffer::Format arg4 ;
43160   Dali::FrameBufferImage result;
43161
43162   arg1 = (unsigned int)jarg1;
43163   arg2 = (unsigned int)jarg2;
43164   arg3 = (Dali::Pixel::Format)jarg3;
43165   arg4 = (Dali::RenderBuffer::Format)jarg4;
43166   {
43167     try {
43168       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43169     } catch (std::out_of_range& e) {
43170       {
43171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43172       };
43173     } catch (std::exception& e) {
43174       {
43175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43176       };
43177     } catch (...) {
43178       {
43179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43180       };
43181     }
43182   }
43183   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43184   return jresult;
43185 }
43186
43187
43188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43189   void * jresult ;
43190   unsigned int arg1 ;
43191   unsigned int arg2 ;
43192   Dali::Pixel::Format arg3 ;
43193   Dali::FrameBufferImage result;
43194
43195   arg1 = (unsigned int)jarg1;
43196   arg2 = (unsigned int)jarg2;
43197   arg3 = (Dali::Pixel::Format)jarg3;
43198   {
43199     try {
43200       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43201     } catch (std::out_of_range& e) {
43202       {
43203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (std::exception& e) {
43206       {
43207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43216   return jresult;
43217 }
43218
43219
43220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43221   void * jresult ;
43222   unsigned int arg1 ;
43223   unsigned int arg2 ;
43224   Dali::FrameBufferImage result;
43225
43226   arg1 = (unsigned int)jarg1;
43227   arg2 = (unsigned int)jarg2;
43228   {
43229     try {
43230       result = Dali::FrameBufferImage::New(arg1,arg2);
43231     } catch (std::out_of_range& e) {
43232       {
43233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43234       };
43235     } catch (std::exception& e) {
43236       {
43237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43238       };
43239     } catch (...) {
43240       {
43241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43242       };
43243     }
43244   }
43245   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43246   return jresult;
43247 }
43248
43249
43250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43251   void * jresult ;
43252   unsigned int arg1 ;
43253   Dali::FrameBufferImage result;
43254
43255   arg1 = (unsigned int)jarg1;
43256   {
43257     try {
43258       result = Dali::FrameBufferImage::New(arg1);
43259     } catch (std::out_of_range& e) {
43260       {
43261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43262       };
43263     } catch (std::exception& e) {
43264       {
43265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43266       };
43267     } catch (...) {
43268       {
43269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43270       };
43271     }
43272   }
43273   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43274   return jresult;
43275 }
43276
43277
43278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43279   void * jresult ;
43280   Dali::FrameBufferImage result;
43281
43282   {
43283     try {
43284       result = Dali::FrameBufferImage::New();
43285     } catch (std::out_of_range& e) {
43286       {
43287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43288       };
43289     } catch (std::exception& e) {
43290       {
43291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43292       };
43293     } catch (...) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43296       };
43297     }
43298   }
43299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43300   return jresult;
43301 }
43302
43303
43304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43305   void * jresult ;
43306   Dali::NativeImageInterface *arg1 = 0 ;
43307   Dali::FrameBufferImage result;
43308
43309   arg1 = (Dali::NativeImageInterface *)jarg1;
43310   if (!arg1) {
43311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43312     return 0;
43313   }
43314   {
43315     try {
43316       result = Dali::FrameBufferImage::New(*arg1);
43317     } catch (std::out_of_range& e) {
43318       {
43319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43320       };
43321     } catch (std::exception& e) {
43322       {
43323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43328       };
43329     }
43330   }
43331   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43337   void * jresult ;
43338   Dali::BaseHandle arg1 ;
43339   Dali::BaseHandle *argp1 ;
43340   Dali::FrameBufferImage result;
43341
43342   argp1 = (Dali::BaseHandle *)jarg1;
43343   if (!argp1) {
43344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43345     return 0;
43346   }
43347   arg1 = *argp1;
43348   {
43349     try {
43350       result = Dali::FrameBufferImage::DownCast(arg1);
43351     } catch (std::out_of_range& e) {
43352       {
43353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (std::exception& e) {
43356       {
43357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43371   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43372
43373   arg1 = (Dali::FrameBufferImage *)jarg1;
43374   {
43375     try {
43376       delete arg1;
43377     } catch (std::out_of_range& e) {
43378       {
43379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43380       };
43381     } catch (std::exception& e) {
43382       {
43383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43384       };
43385     } catch (...) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43388       };
43389     }
43390   }
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43395   void * jresult ;
43396   Dali::FrameBufferImage *arg1 = 0 ;
43397   Dali::FrameBufferImage *result = 0 ;
43398
43399   arg1 = (Dali::FrameBufferImage *)jarg1;
43400   if (!arg1) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43402     return 0;
43403   }
43404   {
43405     try {
43406       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43427   void * jresult ;
43428   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43429   Dali::FrameBufferImage *arg2 = 0 ;
43430   Dali::FrameBufferImage *result = 0 ;
43431
43432   arg1 = (Dali::FrameBufferImage *)jarg1;
43433   arg2 = (Dali::FrameBufferImage *)jarg2;
43434   if (!arg2) {
43435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43436     return 0;
43437   }
43438   {
43439     try {
43440       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43441     } catch (std::out_of_range& e) {
43442       {
43443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (std::exception& e) {
43446       {
43447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43448       };
43449     } catch (...) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43452       };
43453     }
43454   }
43455   jresult = (void *)result;
43456   return jresult;
43457 }
43458
43459
43460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43461   void * jresult ;
43462   Dali::NinePatchImage *result = 0 ;
43463
43464   {
43465     try {
43466       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43467     } catch (std::out_of_range& e) {
43468       {
43469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (std::exception& e) {
43472       {
43473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43474       };
43475     } catch (...) {
43476       {
43477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43478       };
43479     }
43480   }
43481   jresult = (void *)result;
43482   return jresult;
43483 }
43484
43485
43486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43487   void * jresult ;
43488   std::string *arg1 = 0 ;
43489   Dali::NinePatchImage result;
43490
43491   if (!jarg1) {
43492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43493     return 0;
43494   }
43495   std::string arg1_str(jarg1);
43496   arg1 = &arg1_str;
43497   {
43498     try {
43499       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43500     } catch (std::out_of_range& e) {
43501       {
43502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43503       };
43504     } catch (std::exception& e) {
43505       {
43506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43507       };
43508     } catch (...) {
43509       {
43510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43511       };
43512     }
43513   }
43514   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43515
43516   //argout typemap for const std::string&
43517
43518   return jresult;
43519 }
43520
43521
43522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43523   void * jresult ;
43524   Dali::BaseHandle arg1 ;
43525   Dali::BaseHandle *argp1 ;
43526   Dali::NinePatchImage result;
43527
43528   argp1 = (Dali::BaseHandle *)jarg1;
43529   if (!argp1) {
43530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43531     return 0;
43532   }
43533   arg1 = *argp1;
43534   {
43535     try {
43536       result = Dali::NinePatchImage::DownCast(arg1);
43537     } catch (std::out_of_range& e) {
43538       {
43539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43540       };
43541     } catch (std::exception& e) {
43542       {
43543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43544       };
43545     } catch (...) {
43546       {
43547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43548       };
43549     }
43550   }
43551   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43552   return jresult;
43553 }
43554
43555
43556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43557   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43558
43559   arg1 = (Dali::NinePatchImage *)jarg1;
43560   {
43561     try {
43562       delete arg1;
43563     } catch (std::out_of_range& e) {
43564       {
43565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43566       };
43567     } catch (std::exception& e) {
43568       {
43569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43570       };
43571     } catch (...) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43574       };
43575     }
43576   }
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43581   void * jresult ;
43582   Dali::NinePatchImage *arg1 = 0 ;
43583   Dali::NinePatchImage *result = 0 ;
43584
43585   arg1 = (Dali::NinePatchImage *)jarg1;
43586   if (!arg1) {
43587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43588     return 0;
43589   }
43590   {
43591     try {
43592       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607   jresult = (void *)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43613   void * jresult ;
43614   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43615   Dali::NinePatchImage *arg2 = 0 ;
43616   Dali::NinePatchImage *result = 0 ;
43617
43618   arg1 = (Dali::NinePatchImage *)jarg1;
43619   arg2 = (Dali::NinePatchImage *)jarg2;
43620   if (!arg2) {
43621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43622     return 0;
43623   }
43624   {
43625     try {
43626       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
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_NinePatchImage_GetStretchBorders(void * jarg1) {
43647   void * jresult ;
43648   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43649   Dali::Vector4 result;
43650
43651   arg1 = (Dali::NinePatchImage *)jarg1;
43652   {
43653     try {
43654       result = (arg1)->GetStretchBorders();
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43666       };
43667     }
43668   }
43669   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43670   return jresult;
43671 }
43672
43673
43674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43675   void * jresult ;
43676   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43677   Dali::NinePatchImage::StretchRanges *result = 0 ;
43678
43679   arg1 = (Dali::NinePatchImage *)jarg1;
43680   {
43681     try {
43682       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43683     } catch (std::out_of_range& e) {
43684       {
43685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43686       };
43687     } catch (std::exception& e) {
43688       {
43689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43690       };
43691     } catch (...) {
43692       {
43693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43694       };
43695     }
43696   }
43697   jresult = (void *)result;
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43703   void * jresult ;
43704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43705   Dali::NinePatchImage::StretchRanges *result = 0 ;
43706
43707   arg1 = (Dali::NinePatchImage *)jarg1;
43708   {
43709     try {
43710       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43711     } catch (std::out_of_range& e) {
43712       {
43713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43714       };
43715     } catch (std::exception& e) {
43716       {
43717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43718       };
43719     } catch (...) {
43720       {
43721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43722       };
43723     }
43724   }
43725   jresult = (void *)result;
43726   return jresult;
43727 }
43728
43729
43730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43731   void * jresult ;
43732   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43733   Dali::Rect< int > result;
43734
43735   arg1 = (Dali::NinePatchImage *)jarg1;
43736   {
43737     try {
43738       result = (arg1)->GetChildRectangle();
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (...) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43750       };
43751     }
43752   }
43753   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43754   return jresult;
43755 }
43756
43757
43758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43759   void * jresult ;
43760   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43761   Dali::BufferImage result;
43762
43763   arg1 = (Dali::NinePatchImage *)jarg1;
43764   {
43765     try {
43766       result = (arg1)->CreateCroppedBufferImage();
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43774       };
43775     } catch (...) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43778       };
43779     }
43780   }
43781   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43782   return jresult;
43783 }
43784
43785
43786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43787   unsigned int jresult ;
43788   std::string *arg1 = 0 ;
43789   bool result;
43790
43791   if (!jarg1) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43793     return 0;
43794   }
43795   std::string arg1_str(jarg1);
43796   arg1 = &arg1_str;
43797   {
43798     try {
43799       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43800     } catch (std::out_of_range& e) {
43801       {
43802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43803       };
43804     } catch (std::exception& e) {
43805       {
43806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43807       };
43808     } catch (...) {
43809       {
43810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43811       };
43812     }
43813   }
43814   jresult = result;
43815
43816   //argout typemap for const std::string&
43817
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43823   int jresult ;
43824   int result;
43825
43826   result = (int)Dali::CameraActor::Property::TYPE;
43827   jresult = (int)result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43833   int jresult ;
43834   int result;
43835
43836   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43837   jresult = (int)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43843   int jresult ;
43844   int result;
43845
43846   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43847   jresult = (int)result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43853   int jresult ;
43854   int result;
43855
43856   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43857   jresult = (int)result;
43858   return jresult;
43859 }
43860
43861
43862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43863   int jresult ;
43864   int result;
43865
43866   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43867   jresult = (int)result;
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43873   int jresult ;
43874   int result;
43875
43876   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43877   jresult = (int)result;
43878   return jresult;
43879 }
43880
43881
43882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43883   int jresult ;
43884   int result;
43885
43886   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43887   jresult = (int)result;
43888   return jresult;
43889 }
43890
43891
43892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43893   int jresult ;
43894   int result;
43895
43896   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43897   jresult = (int)result;
43898   return jresult;
43899 }
43900
43901
43902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43903   int jresult ;
43904   int result;
43905
43906   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43907   jresult = (int)result;
43908   return jresult;
43909 }
43910
43911
43912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43913   int jresult ;
43914   int result;
43915
43916   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43917   jresult = (int)result;
43918   return jresult;
43919 }
43920
43921
43922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43923   int jresult ;
43924   int result;
43925
43926   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43927   jresult = (int)result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43933   int jresult ;
43934   int result;
43935
43936   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43937   jresult = (int)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43943   int jresult ;
43944   int result;
43945
43946   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43947   jresult = (int)result;
43948   return jresult;
43949 }
43950
43951
43952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43953   int jresult ;
43954   int result;
43955
43956   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43957   jresult = (int)result;
43958   return jresult;
43959 }
43960
43961
43962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43963   void * jresult ;
43964   Dali::CameraActor::Property *result = 0 ;
43965
43966   {
43967     try {
43968       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43969     } catch (std::out_of_range& e) {
43970       {
43971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43972       };
43973     } catch (std::exception& e) {
43974       {
43975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43976       };
43977     } catch (...) {
43978       {
43979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43980       };
43981     }
43982   }
43983   jresult = (void *)result;
43984   return jresult;
43985 }
43986
43987
43988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43989   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43990
43991   arg1 = (Dali::CameraActor::Property *)jarg1;
43992   {
43993     try {
43994       delete arg1;
43995     } catch (std::out_of_range& e) {
43996       {
43997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43998       };
43999     } catch (std::exception& e) {
44000       {
44001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44002       };
44003     } catch (...) {
44004       {
44005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44006       };
44007     }
44008   }
44009 }
44010
44011
44012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44013   void * jresult ;
44014   Dali::CameraActor *result = 0 ;
44015
44016   {
44017     try {
44018       result = (Dali::CameraActor *)new Dali::CameraActor();
44019     } catch (std::out_of_range& e) {
44020       {
44021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44022       };
44023     } catch (std::exception& e) {
44024       {
44025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (...) {
44028       {
44029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44030       };
44031     }
44032   }
44033   jresult = (void *)result;
44034   return jresult;
44035 }
44036
44037
44038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44039   void * jresult ;
44040   Dali::CameraActor result;
44041
44042   {
44043     try {
44044       result = Dali::CameraActor::New();
44045     } catch (std::out_of_range& e) {
44046       {
44047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44048       };
44049     } catch (std::exception& e) {
44050       {
44051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44056       };
44057     }
44058   }
44059   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44060   return jresult;
44061 }
44062
44063
44064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44065   void * jresult ;
44066   Dali::Size *arg1 = 0 ;
44067   Dali::CameraActor result;
44068
44069   arg1 = (Dali::Size *)jarg1;
44070   if (!arg1) {
44071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44072     return 0;
44073   }
44074   {
44075     try {
44076       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44077     } catch (std::out_of_range& e) {
44078       {
44079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44080       };
44081     } catch (std::exception& e) {
44082       {
44083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44084       };
44085     } catch (...) {
44086       {
44087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44088       };
44089     }
44090   }
44091   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44092   return jresult;
44093 }
44094
44095
44096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44097   void * jresult ;
44098   Dali::BaseHandle arg1 ;
44099   Dali::BaseHandle *argp1 ;
44100   Dali::CameraActor result;
44101
44102   argp1 = (Dali::BaseHandle *)jarg1;
44103   if (!argp1) {
44104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44105     return 0;
44106   }
44107   arg1 = *argp1;
44108   {
44109     try {
44110       result = Dali::CameraActor::DownCast(arg1);
44111     } catch (std::out_of_range& e) {
44112       {
44113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44114       };
44115     } catch (std::exception& e) {
44116       {
44117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44118       };
44119     } catch (...) {
44120       {
44121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44122       };
44123     }
44124   }
44125   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44126   return jresult;
44127 }
44128
44129
44130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44131   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44132
44133   arg1 = (Dali::CameraActor *)jarg1;
44134   {
44135     try {
44136       delete arg1;
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44148       };
44149     }
44150   }
44151 }
44152
44153
44154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44155   void * jresult ;
44156   Dali::CameraActor *arg1 = 0 ;
44157   Dali::CameraActor *result = 0 ;
44158
44159   arg1 = (Dali::CameraActor *)jarg1;
44160   if (!arg1) {
44161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44162     return 0;
44163   }
44164   {
44165     try {
44166       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44167     } catch (std::out_of_range& e) {
44168       {
44169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44170       };
44171     } catch (std::exception& e) {
44172       {
44173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44174       };
44175     } catch (...) {
44176       {
44177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44178       };
44179     }
44180   }
44181   jresult = (void *)result;
44182   return jresult;
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44187   void * jresult ;
44188   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44189   Dali::CameraActor *arg2 = 0 ;
44190   Dali::CameraActor *result = 0 ;
44191
44192   arg1 = (Dali::CameraActor *)jarg1;
44193   arg2 = (Dali::CameraActor *)jarg2;
44194   if (!arg2) {
44195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44196     return 0;
44197   }
44198   {
44199     try {
44200       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44201     } catch (std::out_of_range& e) {
44202       {
44203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44204       };
44205     } catch (std::exception& e) {
44206       {
44207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44208       };
44209     } catch (...) {
44210       {
44211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44212       };
44213     }
44214   }
44215   jresult = (void *)result;
44216   return jresult;
44217 }
44218
44219
44220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44221   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44222   Dali::Camera::Type arg2 ;
44223
44224   arg1 = (Dali::CameraActor *)jarg1;
44225   arg2 = (Dali::Camera::Type)jarg2;
44226   {
44227     try {
44228       (arg1)->SetType(arg2);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44236       };
44237     } catch (...) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44240       };
44241     }
44242   }
44243 }
44244
44245
44246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44247   int jresult ;
44248   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44249   Dali::Camera::Type result;
44250
44251   arg1 = (Dali::CameraActor *)jarg1;
44252   {
44253     try {
44254       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
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 = (int)result;
44270   return jresult;
44271 }
44272
44273
44274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44275   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44276   Dali::Camera::ProjectionMode arg2 ;
44277
44278   arg1 = (Dali::CameraActor *)jarg1;
44279   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44280   {
44281     try {
44282       (arg1)->SetProjectionMode(arg2);
44283     } catch (std::out_of_range& e) {
44284       {
44285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44286       };
44287     } catch (std::exception& e) {
44288       {
44289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (...) {
44292       {
44293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44294       };
44295     }
44296   }
44297 }
44298
44299
44300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44301   int jresult ;
44302   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44303   Dali::Camera::ProjectionMode result;
44304
44305   arg1 = (Dali::CameraActor *)jarg1;
44306   {
44307     try {
44308       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44309     } catch (std::out_of_range& e) {
44310       {
44311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44312       };
44313     } catch (std::exception& e) {
44314       {
44315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44316       };
44317     } catch (...) {
44318       {
44319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44320       };
44321     }
44322   }
44323   jresult = (int)result;
44324   return jresult;
44325 }
44326
44327
44328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44330   float arg2 ;
44331
44332   arg1 = (Dali::CameraActor *)jarg1;
44333   arg2 = (float)jarg2;
44334   {
44335     try {
44336       (arg1)->SetFieldOfView(arg2);
44337     } catch (std::out_of_range& e) {
44338       {
44339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44340       };
44341     } catch (std::exception& e) {
44342       {
44343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44344       };
44345     } catch (...) {
44346       {
44347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44348       };
44349     }
44350   }
44351 }
44352
44353
44354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44355   float jresult ;
44356   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44357   float result;
44358
44359   arg1 = (Dali::CameraActor *)jarg1;
44360   {
44361     try {
44362       result = (float)(arg1)->GetFieldOfView();
44363     } catch (std::out_of_range& e) {
44364       {
44365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44366       };
44367     } catch (std::exception& e) {
44368       {
44369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44370       };
44371     } catch (...) {
44372       {
44373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44374       };
44375     }
44376   }
44377   jresult = result;
44378   return jresult;
44379 }
44380
44381
44382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44384   float arg2 ;
44385
44386   arg1 = (Dali::CameraActor *)jarg1;
44387   arg2 = (float)jarg2;
44388   {
44389     try {
44390       (arg1)->SetAspectRatio(arg2);
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44398       };
44399     } catch (...) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44402       };
44403     }
44404   }
44405 }
44406
44407
44408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44409   float jresult ;
44410   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44411   float result;
44412
44413   arg1 = (Dali::CameraActor *)jarg1;
44414   {
44415     try {
44416       result = (float)(arg1)->GetAspectRatio();
44417     } catch (std::out_of_range& e) {
44418       {
44419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44420       };
44421     } catch (std::exception& e) {
44422       {
44423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44424       };
44425     } catch (...) {
44426       {
44427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44428       };
44429     }
44430   }
44431   jresult = result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44437   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44438   float arg2 ;
44439
44440   arg1 = (Dali::CameraActor *)jarg1;
44441   arg2 = (float)jarg2;
44442   {
44443     try {
44444       (arg1)->SetNearClippingPlane(arg2);
44445     } catch (std::out_of_range& e) {
44446       {
44447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44448       };
44449     } catch (std::exception& e) {
44450       {
44451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44452       };
44453     } catch (...) {
44454       {
44455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44456       };
44457     }
44458   }
44459 }
44460
44461
44462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44463   float jresult ;
44464   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44465   float result;
44466
44467   arg1 = (Dali::CameraActor *)jarg1;
44468   {
44469     try {
44470       result = (float)(arg1)->GetNearClippingPlane();
44471     } catch (std::out_of_range& e) {
44472       {
44473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44474       };
44475     } catch (std::exception& e) {
44476       {
44477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44478       };
44479     } catch (...) {
44480       {
44481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44482       };
44483     }
44484   }
44485   jresult = result;
44486   return jresult;
44487 }
44488
44489
44490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44491   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44492   float arg2 ;
44493
44494   arg1 = (Dali::CameraActor *)jarg1;
44495   arg2 = (float)jarg2;
44496   {
44497     try {
44498       (arg1)->SetFarClippingPlane(arg2);
44499     } catch (std::out_of_range& e) {
44500       {
44501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44502       };
44503     } catch (std::exception& e) {
44504       {
44505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44506       };
44507     } catch (...) {
44508       {
44509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44510       };
44511     }
44512   }
44513 }
44514
44515
44516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44517   float jresult ;
44518   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44519   float result;
44520
44521   arg1 = (Dali::CameraActor *)jarg1;
44522   {
44523     try {
44524       result = (float)(arg1)->GetFarClippingPlane();
44525     } catch (std::out_of_range& e) {
44526       {
44527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44528       };
44529     } catch (std::exception& e) {
44530       {
44531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44532       };
44533     } catch (...) {
44534       {
44535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44536       };
44537     }
44538   }
44539   jresult = result;
44540   return jresult;
44541 }
44542
44543
44544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44545   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44546   Dali::Vector3 *arg2 = 0 ;
44547
44548   arg1 = (Dali::CameraActor *)jarg1;
44549   arg2 = (Dali::Vector3 *)jarg2;
44550   if (!arg2) {
44551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44552     return ;
44553   }
44554   {
44555     try {
44556       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44557     } catch (std::out_of_range& e) {
44558       {
44559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44560       };
44561     } catch (std::exception& e) {
44562       {
44563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (...) {
44566       {
44567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44568       };
44569     }
44570   }
44571 }
44572
44573
44574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44575   void * jresult ;
44576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44577   Dali::Vector3 result;
44578
44579   arg1 = (Dali::CameraActor *)jarg1;
44580   {
44581     try {
44582       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44583     } catch (std::out_of_range& e) {
44584       {
44585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (std::exception& e) {
44588       {
44589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44590       };
44591     } catch (...) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44594       };
44595     }
44596   }
44597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44598   return jresult;
44599 }
44600
44601
44602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44604   bool arg2 ;
44605
44606   arg1 = (Dali::CameraActor *)jarg1;
44607   arg2 = jarg2 ? true : false;
44608   {
44609     try {
44610       (arg1)->SetInvertYAxis(arg2);
44611     } catch (std::out_of_range& e) {
44612       {
44613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44614       };
44615     } catch (std::exception& e) {
44616       {
44617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44618       };
44619     } catch (...) {
44620       {
44621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44622       };
44623     }
44624   }
44625 }
44626
44627
44628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44629   unsigned int jresult ;
44630   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44631   bool result;
44632
44633   arg1 = (Dali::CameraActor *)jarg1;
44634   {
44635     try {
44636       result = (bool)(arg1)->GetInvertYAxis();
44637     } catch (std::out_of_range& e) {
44638       {
44639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44640       };
44641     } catch (std::exception& e) {
44642       {
44643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44644       };
44645     } catch (...) {
44646       {
44647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44648       };
44649     }
44650   }
44651   jresult = result;
44652   return jresult;
44653 }
44654
44655
44656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44657   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44658   Dali::Size *arg2 = 0 ;
44659
44660   arg1 = (Dali::CameraActor *)jarg1;
44661   arg2 = (Dali::Size *)jarg2;
44662   if (!arg2) {
44663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44664     return ;
44665   }
44666   {
44667     try {
44668       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44676       };
44677     } catch (...) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44680       };
44681     }
44682   }
44683 }
44684
44685
44686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44687   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44688   Dali::Size *arg2 = 0 ;
44689
44690   arg1 = (Dali::CameraActor *)jarg1;
44691   arg2 = (Dali::Size *)jarg2;
44692   if (!arg2) {
44693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44694     return ;
44695   }
44696   {
44697     try {
44698       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44710       };
44711     }
44712   }
44713 }
44714
44715
44716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44717   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44718   float arg2 ;
44719   float arg3 ;
44720   float arg4 ;
44721   float arg5 ;
44722   float arg6 ;
44723   float arg7 ;
44724
44725   arg1 = (Dali::CameraActor *)jarg1;
44726   arg2 = (float)jarg2;
44727   arg3 = (float)jarg3;
44728   arg4 = (float)jarg4;
44729   arg5 = (float)jarg5;
44730   arg6 = (float)jarg6;
44731   arg7 = (float)jarg7;
44732   {
44733     try {
44734       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44735     } catch (std::out_of_range& e) {
44736       {
44737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44738       };
44739     } catch (std::exception& e) {
44740       {
44741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44742       };
44743     } catch (...) {
44744       {
44745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44746       };
44747     }
44748   }
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44753   void * jresult ;
44754   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44755
44756   {
44757     try {
44758       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44759     } catch (std::out_of_range& e) {
44760       {
44761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (std::exception& e) {
44764       {
44765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44766       };
44767     } catch (...) {
44768       {
44769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44770       };
44771     }
44772   }
44773   jresult = (void *)result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44779   void * jresult ;
44780   std::string arg1 ;
44781   Dali::Property::Value arg2 ;
44782   Dali::Property::Value *argp2 ;
44783   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44784
44785   if (!jarg1) {
44786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44787     return 0;
44788   }
44789   (&arg1)->assign(jarg1);
44790   argp2 = (Dali::Property::Value *)jarg2;
44791   if (!argp2) {
44792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44793     return 0;
44794   }
44795   arg2 = *argp2;
44796   {
44797     try {
44798       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44799     } catch (std::out_of_range& e) {
44800       {
44801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44802       };
44803     } catch (std::exception& e) {
44804       {
44805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44806       };
44807     } catch (...) {
44808       {
44809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44810       };
44811     }
44812   }
44813   jresult = (void *)result;
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44819   void * jresult ;
44820   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44821   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44822
44823   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44824   if (!arg1) {
44825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44826     return 0;
44827   }
44828   {
44829     try {
44830       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);
44831     } catch (std::out_of_range& e) {
44832       {
44833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (std::exception& e) {
44836       {
44837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44838       };
44839     } catch (...) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44842       };
44843     }
44844   }
44845   jresult = (void *)result;
44846   return jresult;
44847 }
44848
44849
44850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44851   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44852   std::string *arg2 = 0 ;
44853
44854   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44855   if (!jarg2) {
44856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44857     return ;
44858   }
44859   std::string arg2_str(jarg2);
44860   arg2 = &arg2_str;
44861   if (arg1) (arg1)->first = *arg2;
44862
44863   //argout typemap for const std::string&
44864
44865 }
44866
44867
44868 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44869   char * jresult ;
44870   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44871   std::string *result = 0 ;
44872
44873   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44874   result = (std::string *) & ((arg1)->first);
44875   jresult = SWIG_csharp_string_callback(result->c_str());
44876   return jresult;
44877 }
44878
44879
44880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44881   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44882   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44883
44884   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44885   arg2 = (Dali::Property::Value *)jarg2;
44886   if (arg1) (arg1)->second = *arg2;
44887 }
44888
44889
44890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44891   void * jresult ;
44892   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44893   Dali::Property::Value *result = 0 ;
44894
44895   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44896   result = (Dali::Property::Value *)& ((arg1)->second);
44897   jresult = (void *)result;
44898   return jresult;
44899 }
44900
44901
44902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44903   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44904
44905   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44906   {
44907     try {
44908       delete arg1;
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (...) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44920       };
44921     }
44922   }
44923 }
44924
44925
44926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44927   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44928
44929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44930   {
44931     try {
44932       (arg1)->clear();
44933     } catch (std::out_of_range& e) {
44934       {
44935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44936       };
44937     } catch (std::exception& e) {
44938       {
44939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44940       };
44941     } catch (...) {
44942       {
44943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44944       };
44945     }
44946   }
44947 }
44948
44949
44950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44951   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44952   Dali::TouchPoint *arg2 = 0 ;
44953
44954   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44955   arg2 = (Dali::TouchPoint *)jarg2;
44956   if (!arg2) {
44957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44958     return ;
44959   }
44960   {
44961     try {
44962       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44963     } catch (std::out_of_range& e) {
44964       {
44965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44966       };
44967     } catch (std::exception& e) {
44968       {
44969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44970       };
44971     } catch (...) {
44972       {
44973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44974       };
44975     }
44976   }
44977 }
44978
44979
44980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44981   unsigned long jresult ;
44982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44983   std::vector< Dali::TouchPoint >::size_type result;
44984
44985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44986   {
44987     try {
44988       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45000       };
45001     }
45002   }
45003   jresult = (unsigned long)result;
45004   return jresult;
45005 }
45006
45007
45008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45009   unsigned long jresult ;
45010   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45011   std::vector< Dali::TouchPoint >::size_type result;
45012
45013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45014   {
45015     try {
45016       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45017     } catch (std::out_of_range& e) {
45018       {
45019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45020       };
45021     } catch (std::exception& e) {
45022       {
45023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45024       };
45025     } catch (...) {
45026       {
45027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45028       };
45029     }
45030   }
45031   jresult = (unsigned long)result;
45032   return jresult;
45033 }
45034
45035
45036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45037   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45038   std::vector< Dali::TouchPoint >::size_type arg2 ;
45039
45040   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45041   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45042   {
45043     try {
45044       (arg1)->reserve(arg2);
45045     } catch (std::out_of_range& e) {
45046       {
45047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45048       };
45049     } catch (std::exception& e) {
45050       {
45051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45052       };
45053     } catch (...) {
45054       {
45055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45056       };
45057     }
45058   }
45059 }
45060
45061
45062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45063   void * jresult ;
45064   std::vector< Dali::TouchPoint > *result = 0 ;
45065
45066   {
45067     try {
45068       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45069     } catch (std::out_of_range& e) {
45070       {
45071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45072       };
45073     } catch (std::exception& e) {
45074       {
45075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (...) {
45078       {
45079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45080       };
45081     }
45082   }
45083   jresult = (void *)result;
45084   return jresult;
45085 }
45086
45087
45088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45089   void * jresult ;
45090   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45091   std::vector< Dali::TouchPoint > *result = 0 ;
45092
45093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45094   if (!arg1) {
45095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45096     return 0;
45097   }
45098   {
45099     try {
45100       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45101     } catch (std::out_of_range& e) {
45102       {
45103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45104       };
45105     } catch (std::exception& e) {
45106       {
45107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45112       };
45113     }
45114   }
45115   jresult = (void *)result;
45116   return jresult;
45117 }
45118
45119
45120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45121   void * jresult ;
45122   int arg1 ;
45123   std::vector< Dali::TouchPoint > *result = 0 ;
45124
45125   arg1 = (int)jarg1;
45126   {
45127     try {
45128       try {
45129         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45130       }
45131       catch(std::out_of_range &_e) {
45132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45133         return 0;
45134       }
45135
45136     } catch (std::out_of_range& e) {
45137       {
45138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45139       };
45140     } catch (std::exception& e) {
45141       {
45142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45143       };
45144     } catch (...) {
45145       {
45146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45147       };
45148     }
45149   }
45150   jresult = (void *)result;
45151   return jresult;
45152 }
45153
45154
45155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45156   void * jresult ;
45157   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45158   int arg2 ;
45159   SwigValueWrapper< Dali::TouchPoint > result;
45160
45161   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45162   arg2 = (int)jarg2;
45163   {
45164     try {
45165       try {
45166         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45167       }
45168       catch(std::out_of_range &_e) {
45169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45170         return 0;
45171       }
45172
45173     } catch (std::out_of_range& e) {
45174       {
45175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45176       };
45177     } catch (std::exception& e) {
45178       {
45179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45180       };
45181     } catch (...) {
45182       {
45183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45184       };
45185     }
45186   }
45187   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45188   return jresult;
45189 }
45190
45191
45192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45193   void * jresult ;
45194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45195   int arg2 ;
45196   Dali::TouchPoint *result = 0 ;
45197
45198   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45199   arg2 = (int)jarg2;
45200   {
45201     try {
45202       try {
45203         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45204       }
45205       catch(std::out_of_range &_e) {
45206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45207         return 0;
45208       }
45209
45210     } catch (std::out_of_range& e) {
45211       {
45212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45213       };
45214     } catch (std::exception& e) {
45215       {
45216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45217       };
45218     } catch (...) {
45219       {
45220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45221       };
45222     }
45223   }
45224   jresult = (void *)result;
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45230   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45231   int arg2 ;
45232   Dali::TouchPoint *arg3 = 0 ;
45233
45234   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45235   arg2 = (int)jarg2;
45236   arg3 = (Dali::TouchPoint *)jarg3;
45237   if (!arg3) {
45238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45239     return ;
45240   }
45241   {
45242     try {
45243       try {
45244         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45245       }
45246       catch(std::out_of_range &_e) {
45247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45248         return ;
45249       }
45250
45251     } catch (std::out_of_range& e) {
45252       {
45253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45254       };
45255     } catch (std::exception& e) {
45256       {
45257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45258       };
45259     } catch (...) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45262       };
45263     }
45264   }
45265 }
45266
45267
45268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45269   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45270   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45271
45272   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45273   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45274   if (!arg2) {
45275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45276     return ;
45277   }
45278   {
45279     try {
45280       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45281     } catch (std::out_of_range& e) {
45282       {
45283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (std::exception& e) {
45286       {
45287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45292       };
45293     }
45294   }
45295 }
45296
45297
45298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45299   void * jresult ;
45300   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45301   int arg2 ;
45302   int arg3 ;
45303   std::vector< Dali::TouchPoint > *result = 0 ;
45304
45305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45306   arg2 = (int)jarg2;
45307   arg3 = (int)jarg3;
45308   {
45309     try {
45310       try {
45311         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45312       }
45313       catch(std::out_of_range &_e) {
45314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45315         return 0;
45316       }
45317       catch(std::invalid_argument &_e) {
45318         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45319         return 0;
45320       }
45321
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45333       };
45334     }
45335   }
45336   jresult = (void *)result;
45337   return jresult;
45338 }
45339
45340
45341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45342   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45343   int arg2 ;
45344   Dali::TouchPoint *arg3 = 0 ;
45345
45346   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45347   arg2 = (int)jarg2;
45348   arg3 = (Dali::TouchPoint *)jarg3;
45349   if (!arg3) {
45350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45351     return ;
45352   }
45353   {
45354     try {
45355       try {
45356         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45357       }
45358       catch(std::out_of_range &_e) {
45359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45360         return ;
45361       }
45362
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_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45381   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45382   int arg2 ;
45383   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45384
45385   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45386   arg2 = (int)jarg2;
45387   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45388   if (!arg3) {
45389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45390     return ;
45391   }
45392   {
45393     try {
45394       try {
45395         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45396       }
45397       catch(std::out_of_range &_e) {
45398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45399         return ;
45400       }
45401
45402     } catch (std::out_of_range& e) {
45403       {
45404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45405       };
45406     } catch (std::exception& e) {
45407       {
45408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45409       };
45410     } catch (...) {
45411       {
45412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45413       };
45414     }
45415   }
45416 }
45417
45418
45419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45420   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45421   int arg2 ;
45422
45423   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45424   arg2 = (int)jarg2;
45425   {
45426     try {
45427       try {
45428         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45429       }
45430       catch(std::out_of_range &_e) {
45431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45432         return ;
45433       }
45434
45435     } catch (std::out_of_range& e) {
45436       {
45437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45438       };
45439     } catch (std::exception& e) {
45440       {
45441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45442       };
45443     } catch (...) {
45444       {
45445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45446       };
45447     }
45448   }
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45453   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45454   int arg2 ;
45455   int arg3 ;
45456
45457   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45458   arg2 = (int)jarg2;
45459   arg3 = (int)jarg3;
45460   {
45461     try {
45462       try {
45463         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45464       }
45465       catch(std::out_of_range &_e) {
45466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45467         return ;
45468       }
45469       catch(std::invalid_argument &_e) {
45470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45471         return ;
45472       }
45473
45474     } catch (std::out_of_range& e) {
45475       {
45476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45477       };
45478     } catch (std::exception& e) {
45479       {
45480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45485       };
45486     }
45487   }
45488 }
45489
45490
45491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45492   void * jresult ;
45493   Dali::TouchPoint *arg1 = 0 ;
45494   int arg2 ;
45495   std::vector< Dali::TouchPoint > *result = 0 ;
45496
45497   arg1 = (Dali::TouchPoint *)jarg1;
45498   if (!arg1) {
45499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45500     return 0;
45501   }
45502   arg2 = (int)jarg2;
45503   {
45504     try {
45505       try {
45506         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45507       }
45508       catch(std::out_of_range &_e) {
45509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45510         return 0;
45511       }
45512
45513     } catch (std::out_of_range& e) {
45514       {
45515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45516       };
45517     } catch (std::exception& e) {
45518       {
45519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45520       };
45521     } catch (...) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45524       };
45525     }
45526   }
45527   jresult = (void *)result;
45528   return jresult;
45529 }
45530
45531
45532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45533   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45534
45535   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45536   {
45537     try {
45538       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (...) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45550       };
45551     }
45552   }
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45557   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45558   int arg2 ;
45559   int arg3 ;
45560
45561   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45562   arg2 = (int)jarg2;
45563   arg3 = (int)jarg3;
45564   {
45565     try {
45566       try {
45567         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45568       }
45569       catch(std::out_of_range &_e) {
45570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45571         return ;
45572       }
45573       catch(std::invalid_argument &_e) {
45574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45575         return ;
45576       }
45577
45578     } catch (std::out_of_range& e) {
45579       {
45580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45581       };
45582     } catch (std::exception& e) {
45583       {
45584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45585       };
45586     } catch (...) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45589       };
45590     }
45591   }
45592 }
45593
45594
45595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45596   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45597   int arg2 ;
45598   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45599
45600   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45601   arg2 = (int)jarg2;
45602   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45603   if (!arg3) {
45604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45605     return ;
45606   }
45607   {
45608     try {
45609       try {
45610         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45611       }
45612       catch(std::out_of_range &_e) {
45613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45614         return ;
45615       }
45616
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45628       };
45629     }
45630   }
45631 }
45632
45633
45634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45635   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45636
45637   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45638   {
45639     try {
45640       delete arg1;
45641     } catch (std::out_of_range& e) {
45642       {
45643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45644       };
45645     } catch (std::exception& e) {
45646       {
45647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45648       };
45649     } catch (...) {
45650       {
45651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45652       };
45653     }
45654   }
45655 }
45656
45657
45658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45659   void * jresult ;
45660   Dali::Rect< int > *result = 0 ;
45661
45662   {
45663     try {
45664       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679   jresult = (void *)result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45685   void * jresult ;
45686   int arg1 ;
45687   int arg2 ;
45688   int arg3 ;
45689   int arg4 ;
45690   Dali::Rect< int > *result = 0 ;
45691
45692   arg1 = (int)jarg1;
45693   arg2 = (int)jarg2;
45694   arg3 = (int)jarg3;
45695   arg4 = (int)jarg4;
45696   {
45697     try {
45698       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45699     } catch (std::out_of_range& e) {
45700       {
45701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45702       };
45703     } catch (std::exception& e) {
45704       {
45705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45710       };
45711     }
45712   }
45713   jresult = (void *)result;
45714   return jresult;
45715 }
45716
45717
45718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45719   void * jresult ;
45720   Dali::Rect< int > *arg1 = 0 ;
45721   Dali::Rect< int > *result = 0 ;
45722
45723   arg1 = (Dali::Rect< int > *)jarg1;
45724   if (!arg1) {
45725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45726     return 0;
45727   }
45728   {
45729     try {
45730       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45731     } catch (std::out_of_range& e) {
45732       {
45733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45734       };
45735     } catch (std::exception& e) {
45736       {
45737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45738       };
45739     } catch (...) {
45740       {
45741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45742       };
45743     }
45744   }
45745   jresult = (void *)result;
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45751   void * jresult ;
45752   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45753   Dali::Rect< int > *arg2 = 0 ;
45754   Dali::Rect< int > *result = 0 ;
45755
45756   arg1 = (Dali::Rect< int > *)jarg1;
45757   arg2 = (Dali::Rect< int > *)jarg2;
45758   if (!arg2) {
45759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45760     return 0;
45761   }
45762   {
45763     try {
45764       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
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_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45785   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45786   int arg2 ;
45787   int arg3 ;
45788   int arg4 ;
45789   int arg5 ;
45790
45791   arg1 = (Dali::Rect< int > *)jarg1;
45792   arg2 = (int)jarg2;
45793   arg3 = (int)jarg3;
45794   arg4 = (int)jarg4;
45795   arg5 = (int)jarg5;
45796   {
45797     try {
45798       (arg1)->Set(arg2,arg3,arg4,arg5);
45799     } catch (std::out_of_range& e) {
45800       {
45801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45802       };
45803     } catch (std::exception& e) {
45804       {
45805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45810       };
45811     }
45812   }
45813 }
45814
45815
45816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45817   unsigned int jresult ;
45818   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45819   bool result;
45820
45821   arg1 = (Dali::Rect< int > *)jarg1;
45822   {
45823     try {
45824       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45825     } catch (std::out_of_range& e) {
45826       {
45827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45828       };
45829     } catch (std::exception& e) {
45830       {
45831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45832       };
45833     } catch (...) {
45834       {
45835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45836       };
45837     }
45838   }
45839   jresult = result;
45840   return jresult;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45845   int jresult ;
45846   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45847   int result;
45848
45849   arg1 = (Dali::Rect< int > *)jarg1;
45850   {
45851     try {
45852       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45853     } catch (std::out_of_range& e) {
45854       {
45855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45856       };
45857     } catch (std::exception& e) {
45858       {
45859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45860       };
45861     } catch (...) {
45862       {
45863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45864       };
45865     }
45866   }
45867   jresult = result;
45868   return jresult;
45869 }
45870
45871
45872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45873   int jresult ;
45874   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45875   int result;
45876
45877   arg1 = (Dali::Rect< int > *)jarg1;
45878   {
45879     try {
45880       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45881     } catch (std::out_of_range& e) {
45882       {
45883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45884       };
45885     } catch (std::exception& e) {
45886       {
45887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45892       };
45893     }
45894   }
45895   jresult = result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45901   int jresult ;
45902   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45903   int result;
45904
45905   arg1 = (Dali::Rect< int > *)jarg1;
45906   {
45907     try {
45908       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (...) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45920       };
45921     }
45922   }
45923   jresult = result;
45924   return jresult;
45925 }
45926
45927
45928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45929   int jresult ;
45930   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45931   int result;
45932
45933   arg1 = (Dali::Rect< int > *)jarg1;
45934   {
45935     try {
45936       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45937     } catch (std::out_of_range& e) {
45938       {
45939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45940       };
45941     } catch (std::exception& e) {
45942       {
45943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45944       };
45945     } catch (...) {
45946       {
45947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45948       };
45949     }
45950   }
45951   jresult = result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45957   int jresult ;
45958   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45959   int result;
45960
45961   arg1 = (Dali::Rect< int > *)jarg1;
45962   {
45963     try {
45964       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45965     } catch (std::out_of_range& e) {
45966       {
45967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45968       };
45969     } catch (std::exception& e) {
45970       {
45971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45972       };
45973     } catch (...) {
45974       {
45975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45976       };
45977     }
45978   }
45979   jresult = result;
45980   return jresult;
45981 }
45982
45983
45984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45985   unsigned int jresult ;
45986   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45987   Dali::Rect< int > *arg2 = 0 ;
45988   bool result;
45989
45990   arg1 = (Dali::Rect< int > *)jarg1;
45991   arg2 = (Dali::Rect< int > *)jarg2;
45992   if (!arg2) {
45993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45994     return 0;
45995   }
45996   {
45997     try {
45998       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*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 = result;
46014   return jresult;
46015 }
46016
46017
46018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46019   unsigned int jresult ;
46020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46021   Dali::Rect< int > *arg2 = 0 ;
46022   bool result;
46023
46024   arg1 = (Dali::Rect< int > *)jarg1;
46025   arg2 = (Dali::Rect< int > *)jarg2;
46026   if (!arg2) {
46027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46028     return 0;
46029   }
46030   {
46031     try {
46032       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
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 = result;
46048   return jresult;
46049 }
46050
46051
46052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
46053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46054   int arg2 ;
46055
46056   arg1 = (Dali::Rect< int > *)jarg1;
46057   arg2 = (int)jarg2;
46058   if (arg1) (arg1)->x = arg2;
46059 }
46060
46061
46062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
46063   int jresult ;
46064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46065   int result;
46066
46067   arg1 = (Dali::Rect< int > *)jarg1;
46068   result = (int) ((arg1)->x);
46069   jresult = result;
46070   return jresult;
46071 }
46072
46073
46074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
46075   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46076   int arg2 ;
46077
46078   arg1 = (Dali::Rect< int > *)jarg1;
46079   arg2 = (int)jarg2;
46080   if (arg1) (arg1)->left = arg2;
46081 }
46082
46083
46084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46085   int jresult ;
46086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46087   int result;
46088
46089   arg1 = (Dali::Rect< int > *)jarg1;
46090   result = (int) ((arg1)->left);
46091   jresult = result;
46092   return jresult;
46093 }
46094
46095
46096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46098   int arg2 ;
46099
46100   arg1 = (Dali::Rect< int > *)jarg1;
46101   arg2 = (int)jarg2;
46102   if (arg1) (arg1)->y = arg2;
46103 }
46104
46105
46106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46107   int jresult ;
46108   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46109   int result;
46110
46111   arg1 = (Dali::Rect< int > *)jarg1;
46112   result = (int) ((arg1)->y);
46113   jresult = result;
46114   return jresult;
46115 }
46116
46117
46118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46120   int arg2 ;
46121
46122   arg1 = (Dali::Rect< int > *)jarg1;
46123   arg2 = (int)jarg2;
46124   if (arg1) (arg1)->right = arg2;
46125 }
46126
46127
46128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46129   int jresult ;
46130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46131   int result;
46132
46133   arg1 = (Dali::Rect< int > *)jarg1;
46134   result = (int) ((arg1)->right);
46135   jresult = result;
46136   return jresult;
46137 }
46138
46139
46140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46141   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46142   int arg2 ;
46143
46144   arg1 = (Dali::Rect< int > *)jarg1;
46145   arg2 = (int)jarg2;
46146   if (arg1) (arg1)->width = arg2;
46147 }
46148
46149
46150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46151   int jresult ;
46152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46153   int result;
46154
46155   arg1 = (Dali::Rect< int > *)jarg1;
46156   result = (int) ((arg1)->width);
46157   jresult = result;
46158   return jresult;
46159 }
46160
46161
46162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46164   int arg2 ;
46165
46166   arg1 = (Dali::Rect< int > *)jarg1;
46167   arg2 = (int)jarg2;
46168   if (arg1) (arg1)->bottom = arg2;
46169 }
46170
46171
46172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46173   int jresult ;
46174   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46175   int result;
46176
46177   arg1 = (Dali::Rect< int > *)jarg1;
46178   result = (int) ((arg1)->bottom);
46179   jresult = result;
46180   return jresult;
46181 }
46182
46183
46184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46185   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46186   int arg2 ;
46187
46188   arg1 = (Dali::Rect< int > *)jarg1;
46189   arg2 = (int)jarg2;
46190   if (arg1) (arg1)->height = arg2;
46191 }
46192
46193
46194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46195   int jresult ;
46196   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46197   int result;
46198
46199   arg1 = (Dali::Rect< int > *)jarg1;
46200   result = (int) ((arg1)->height);
46201   jresult = result;
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46207   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46208   int arg2 ;
46209
46210   arg1 = (Dali::Rect< int > *)jarg1;
46211   arg2 = (int)jarg2;
46212   if (arg1) (arg1)->top = arg2;
46213 }
46214
46215
46216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46217   int jresult ;
46218   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46219   int result;
46220
46221   arg1 = (Dali::Rect< int > *)jarg1;
46222   result = (int) ((arg1)->top);
46223   jresult = result;
46224   return jresult;
46225 }
46226
46227
46228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46229   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46230
46231   arg1 = (Dali::Rect< int > *)jarg1;
46232   {
46233     try {
46234       delete arg1;
46235     } catch (std::out_of_range& e) {
46236       {
46237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46238       };
46239     } catch (std::exception& e) {
46240       {
46241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46242       };
46243     } catch (...) {
46244       {
46245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46246       };
46247     }
46248   }
46249 }
46250
46251
46252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46253   void * jresult ;
46254   Dali::Rect< float > *result = 0 ;
46255
46256   {
46257     try {
46258       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46270       };
46271     }
46272   }
46273   jresult = (void *)result;
46274   return jresult;
46275 }
46276
46277
46278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46279   void * jresult ;
46280   float arg1 ;
46281   float arg2 ;
46282   float arg3 ;
46283   float arg4 ;
46284   Dali::Rect< float > *result = 0 ;
46285
46286   arg1 = (float)jarg1;
46287   arg2 = (float)jarg2;
46288   arg3 = (float)jarg3;
46289   arg4 = (float)jarg4;
46290   {
46291     try {
46292       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46300       };
46301     } catch (...) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46304       };
46305     }
46306   }
46307   jresult = (void *)result;
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46313   void * jresult ;
46314   Dali::Rect< float > *arg1 = 0 ;
46315   Dali::Rect< float > *result = 0 ;
46316
46317   arg1 = (Dali::Rect< float > *)jarg1;
46318   if (!arg1) {
46319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46320     return 0;
46321   }
46322   {
46323     try {
46324       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46325     } catch (std::out_of_range& e) {
46326       {
46327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46328       };
46329     } catch (std::exception& e) {
46330       {
46331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46332       };
46333     } catch (...) {
46334       {
46335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46336       };
46337     }
46338   }
46339   jresult = (void *)result;
46340   return jresult;
46341 }
46342
46343
46344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46345   void * jresult ;
46346   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46347   Dali::Rect< float > *arg2 = 0 ;
46348   Dali::Rect< float > *result = 0 ;
46349
46350   arg1 = (Dali::Rect< float > *)jarg1;
46351   arg2 = (Dali::Rect< float > *)jarg2;
46352   if (!arg2) {
46353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46354     return 0;
46355   }
46356   {
46357     try {
46358       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46359     } catch (std::out_of_range& e) {
46360       {
46361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46362       };
46363     } catch (std::exception& e) {
46364       {
46365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46366       };
46367     } catch (...) {
46368       {
46369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46370       };
46371     }
46372   }
46373   jresult = (void *)result;
46374   return jresult;
46375 }
46376
46377
46378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46379   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46380   float arg2 ;
46381   float arg3 ;
46382   float arg4 ;
46383   float arg5 ;
46384
46385   arg1 = (Dali::Rect< float > *)jarg1;
46386   arg2 = (float)jarg2;
46387   arg3 = (float)jarg3;
46388   arg4 = (float)jarg4;
46389   arg5 = (float)jarg5;
46390   {
46391     try {
46392       (arg1)->Set(arg2,arg3,arg4,arg5);
46393     } catch (std::out_of_range& e) {
46394       {
46395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46396       };
46397     } catch (std::exception& e) {
46398       {
46399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46400       };
46401     } catch (...) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46404       };
46405     }
46406   }
46407 }
46408
46409
46410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46411   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46412   float arg2 ;
46413
46414   arg1 = (Dali::Rect< float > *)jarg1;
46415   arg2 = (float)jarg2;
46416   if (arg1) (arg1)->x = arg2;
46417 }
46418
46419
46420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46421   float jresult ;
46422   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46423   float result;
46424
46425   arg1 = (Dali::Rect< float > *)jarg1;
46426   result = (float) ((arg1)->x);
46427   jresult = result;
46428   return jresult;
46429 }
46430
46431
46432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46433   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46434   float arg2 ;
46435
46436   arg1 = (Dali::Rect< float > *)jarg1;
46437   arg2 = (float)jarg2;
46438   if (arg1) (arg1)->left = arg2;
46439 }
46440
46441
46442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46443   float jresult ;
46444   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46445   float result;
46446
46447   arg1 = (Dali::Rect< float > *)jarg1;
46448   result = (float) ((arg1)->left);
46449   jresult = result;
46450   return jresult;
46451 }
46452
46453
46454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46455   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46456   float arg2 ;
46457
46458   arg1 = (Dali::Rect< float > *)jarg1;
46459   arg2 = (float)jarg2;
46460   if (arg1) (arg1)->y = arg2;
46461 }
46462
46463
46464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46465   float jresult ;
46466   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46467   float result;
46468
46469   arg1 = (Dali::Rect< float > *)jarg1;
46470   result = (float) ((arg1)->y);
46471   jresult = result;
46472   return jresult;
46473 }
46474
46475
46476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46477   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46478   float arg2 ;
46479
46480   arg1 = (Dali::Rect< float > *)jarg1;
46481   arg2 = (float)jarg2;
46482   if (arg1) (arg1)->right = arg2;
46483 }
46484
46485
46486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46487   float jresult ;
46488   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46489   float result;
46490
46491   arg1 = (Dali::Rect< float > *)jarg1;
46492   result = (float) ((arg1)->right);
46493   jresult = result;
46494   return jresult;
46495 }
46496
46497
46498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46499   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46500   float arg2 ;
46501
46502   arg1 = (Dali::Rect< float > *)jarg1;
46503   arg2 = (float)jarg2;
46504   if (arg1) (arg1)->width = arg2;
46505 }
46506
46507
46508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46509   float jresult ;
46510   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46511   float result;
46512
46513   arg1 = (Dali::Rect< float > *)jarg1;
46514   result = (float) ((arg1)->width);
46515   jresult = result;
46516   return jresult;
46517 }
46518
46519
46520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46522   float arg2 ;
46523
46524   arg1 = (Dali::Rect< float > *)jarg1;
46525   arg2 = (float)jarg2;
46526   if (arg1) (arg1)->bottom = arg2;
46527 }
46528
46529
46530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46531   float jresult ;
46532   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46533   float result;
46534
46535   arg1 = (Dali::Rect< float > *)jarg1;
46536   result = (float) ((arg1)->bottom);
46537   jresult = result;
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46543   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46544   float arg2 ;
46545
46546   arg1 = (Dali::Rect< float > *)jarg1;
46547   arg2 = (float)jarg2;
46548   if (arg1) (arg1)->height = arg2;
46549 }
46550
46551
46552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46553   float jresult ;
46554   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46555   float result;
46556
46557   arg1 = (Dali::Rect< float > *)jarg1;
46558   result = (float) ((arg1)->height);
46559   jresult = result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46565   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46566   float arg2 ;
46567
46568   arg1 = (Dali::Rect< float > *)jarg1;
46569   arg2 = (float)jarg2;
46570   if (arg1) (arg1)->top = arg2;
46571 }
46572
46573
46574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46575   float jresult ;
46576   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46577   float result;
46578
46579   arg1 = (Dali::Rect< float > *)jarg1;
46580   result = (float) ((arg1)->top);
46581   jresult = result;
46582   return jresult;
46583 }
46584
46585
46586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46587   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46588
46589   arg1 = (Dali::Rect< float > *)jarg1;
46590   {
46591     try {
46592       delete arg1;
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46600       };
46601     } catch (...) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46604       };
46605     }
46606   }
46607 }
46608
46609
46610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46611   int jresult ;
46612   int result;
46613
46614   result = (int)Dali::Vector< int >::BaseType;
46615   jresult = (int)result;
46616   return jresult;
46617 }
46618
46619
46620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46621   void * jresult ;
46622   Dali::Vector< int > *result = 0 ;
46623
46624   {
46625     try {
46626       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46627     } catch (std::out_of_range& e) {
46628       {
46629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (std::exception& e) {
46632       {
46633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641   jresult = (void *)result;
46642   return jresult;
46643 }
46644
46645
46646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46647   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46648
46649   arg1 = (Dali::Vector< int > *)jarg1;
46650   {
46651     try {
46652       delete arg1;
46653     } catch (std::out_of_range& e) {
46654       {
46655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46656       };
46657     } catch (std::exception& e) {
46658       {
46659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46660       };
46661     } catch (...) {
46662       {
46663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46664       };
46665     }
46666   }
46667 }
46668
46669
46670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46671   void * jresult ;
46672   Dali::Vector< int > *arg1 = 0 ;
46673   Dali::Vector< int > *result = 0 ;
46674
46675   arg1 = (Dali::Vector< int > *)jarg1;
46676   if (!arg1) {
46677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46678     return 0;
46679   }
46680   {
46681     try {
46682       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (...) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46694       };
46695     }
46696   }
46697   jresult = (void *)result;
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46703   void * jresult ;
46704   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46705   Dali::Vector< int > *arg2 = 0 ;
46706   Dali::Vector< int > *result = 0 ;
46707
46708   arg1 = (Dali::Vector< int > *)jarg1;
46709   arg2 = (Dali::Vector< int > *)jarg2;
46710   if (!arg2) {
46711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46712     return 0;
46713   }
46714   {
46715     try {
46716       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46717     } catch (std::out_of_range& e) {
46718       {
46719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46720       };
46721     } catch (std::exception& e) {
46722       {
46723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46724       };
46725     } catch (...) {
46726       {
46727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46728       };
46729     }
46730   }
46731   jresult = (void *)result;
46732   return jresult;
46733 }
46734
46735
46736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46737   void * jresult ;
46738   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46739   Dali::Vector< int >::Iterator result;
46740
46741   arg1 = (Dali::Vector< int > *)jarg1;
46742   {
46743     try {
46744       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46745     } catch (std::out_of_range& e) {
46746       {
46747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46748       };
46749     } catch (std::exception& e) {
46750       {
46751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46752       };
46753     } catch (...) {
46754       {
46755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46756       };
46757     }
46758   }
46759   jresult = (void *)result;
46760   return jresult;
46761 }
46762
46763
46764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46765   void * jresult ;
46766   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46767   Dali::Vector< int >::Iterator result;
46768
46769   arg1 = (Dali::Vector< int > *)jarg1;
46770   {
46771     try {
46772       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
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 = (void *)result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46793   void * jresult ;
46794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46795   Dali::Vector< int >::SizeType arg2 ;
46796   Dali::Vector< int >::ItemType *result = 0 ;
46797
46798   arg1 = (Dali::Vector< int > *)jarg1;
46799   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46800   {
46801     try {
46802       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46803     } catch (std::out_of_range& e) {
46804       {
46805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46806       };
46807     } catch (std::exception& e) {
46808       {
46809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46810       };
46811     } catch (...) {
46812       {
46813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46814       };
46815     }
46816   }
46817   jresult = (void *)result;
46818   return jresult;
46819 }
46820
46821
46822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46823   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46824   Dali::Vector< int >::ItemType *arg2 = 0 ;
46825   Dali::Vector< int >::ItemType temp2 ;
46826
46827   arg1 = (Dali::Vector< int > *)jarg1;
46828   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46829   arg2 = &temp2;
46830   {
46831     try {
46832       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46833     } catch (std::out_of_range& e) {
46834       {
46835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46836       };
46837     } catch (std::exception& e) {
46838       {
46839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46840       };
46841     } catch (...) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46844       };
46845     }
46846   }
46847 }
46848
46849
46850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46851   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46852   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46853   Dali::Vector< int >::ItemType *arg3 = 0 ;
46854   Dali::Vector< int >::ItemType temp3 ;
46855
46856   arg1 = (Dali::Vector< int > *)jarg1;
46857   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46858   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46859   arg3 = &temp3;
46860   {
46861     try {
46862       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46863     } catch (std::out_of_range& e) {
46864       {
46865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (std::exception& e) {
46868       {
46869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46870       };
46871     } catch (...) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46874       };
46875     }
46876   }
46877 }
46878
46879
46880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46881   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46882   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46883   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46884   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46885
46886   arg1 = (Dali::Vector< int > *)jarg1;
46887   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46888   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46889   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46890   {
46891     try {
46892       (arg1)->Insert(arg2,arg3,arg4);
46893     } catch (std::out_of_range& e) {
46894       {
46895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46896       };
46897     } catch (std::exception& e) {
46898       {
46899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46900       };
46901     } catch (...) {
46902       {
46903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46904       };
46905     }
46906   }
46907 }
46908
46909
46910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46911   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46912   Dali::Vector< int >::SizeType arg2 ;
46913
46914   arg1 = (Dali::Vector< int > *)jarg1;
46915   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46916   {
46917     try {
46918       (arg1)->Reserve(arg2);
46919     } catch (std::out_of_range& e) {
46920       {
46921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46922       };
46923     } catch (std::exception& e) {
46924       {
46925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46926       };
46927     } catch (...) {
46928       {
46929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46930       };
46931     }
46932   }
46933 }
46934
46935
46936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46937   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46938   Dali::Vector< int >::SizeType arg2 ;
46939
46940   arg1 = (Dali::Vector< int > *)jarg1;
46941   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46942   {
46943     try {
46944       (arg1)->Resize(arg2);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46952       };
46953     } catch (...) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46956       };
46957     }
46958   }
46959 }
46960
46961
46962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46963   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46964   Dali::Vector< int >::SizeType arg2 ;
46965   Dali::Vector< int >::ItemType *arg3 = 0 ;
46966   Dali::Vector< int >::ItemType temp3 ;
46967
46968   arg1 = (Dali::Vector< int > *)jarg1;
46969   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46970   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46971   arg3 = &temp3;
46972   {
46973     try {
46974       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46975     } catch (std::out_of_range& e) {
46976       {
46977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46978       };
46979     } catch (std::exception& e) {
46980       {
46981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46982       };
46983     } catch (...) {
46984       {
46985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46986       };
46987     }
46988   }
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46993   void * jresult ;
46994   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46995   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46996   Dali::Vector< int >::Iterator result;
46997
46998   arg1 = (Dali::Vector< int > *)jarg1;
46999   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47000   {
47001     try {
47002       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (...) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47014       };
47015     }
47016   }
47017   jresult = (void *)result;
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47023   void * jresult ;
47024   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47025   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47026   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47027   Dali::Vector< int >::Iterator result;
47028
47029   arg1 = (Dali::Vector< int > *)jarg1;
47030   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47031   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47032   {
47033     try {
47034       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47042       };
47043     } catch (...) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47046       };
47047     }
47048   }
47049   jresult = (void *)result;
47050   return jresult;
47051 }
47052
47053
47054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
47055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47056   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47057
47058   arg1 = (Dali::Vector< int > *)jarg1;
47059   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47060   {
47061     try {
47062       (arg1)->Remove(arg2);
47063     } catch (std::out_of_range& e) {
47064       {
47065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47066       };
47067     } catch (std::exception& e) {
47068       {
47069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47070       };
47071     } catch (...) {
47072       {
47073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47074       };
47075     }
47076   }
47077 }
47078
47079
47080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47081   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47082   Dali::Vector< int > *arg2 = 0 ;
47083
47084   arg1 = (Dali::Vector< int > *)jarg1;
47085   arg2 = (Dali::Vector< int > *)jarg2;
47086   if (!arg2) {
47087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47088     return ;
47089   }
47090   {
47091     try {
47092       (arg1)->Swap(*arg2);
47093     } catch (std::out_of_range& e) {
47094       {
47095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47096       };
47097     } catch (std::exception& e) {
47098       {
47099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47100       };
47101     } catch (...) {
47102       {
47103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47104       };
47105     }
47106   }
47107 }
47108
47109
47110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47111   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47112
47113   arg1 = (Dali::Vector< int > *)jarg1;
47114   {
47115     try {
47116       (arg1)->Clear();
47117     } catch (std::out_of_range& e) {
47118       {
47119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47120       };
47121     } catch (std::exception& e) {
47122       {
47123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (...) {
47126       {
47127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47128       };
47129     }
47130   }
47131 }
47132
47133
47134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47135   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47136
47137   arg1 = (Dali::Vector< int > *)jarg1;
47138   {
47139     try {
47140       (arg1)->Release();
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47148       };
47149     } catch (...) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47152       };
47153     }
47154   }
47155 }
47156
47157
47158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47159   int jresult ;
47160   int result;
47161
47162   result = (int)Dali::Vector< float >::BaseType;
47163   jresult = (int)result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47169   void * jresult ;
47170   Dali::Vector< float > *result = 0 ;
47171
47172   {
47173     try {
47174       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47175     } catch (std::out_of_range& e) {
47176       {
47177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47178       };
47179     } catch (std::exception& e) {
47180       {
47181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47182       };
47183     } catch (...) {
47184       {
47185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47186       };
47187     }
47188   }
47189   jresult = (void *)result;
47190   return jresult;
47191 }
47192
47193
47194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47195   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47196
47197   arg1 = (Dali::Vector< float > *)jarg1;
47198   {
47199     try {
47200       delete arg1;
47201     } catch (std::out_of_range& e) {
47202       {
47203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47204       };
47205     } catch (std::exception& e) {
47206       {
47207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (...) {
47210       {
47211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47212       };
47213     }
47214   }
47215 }
47216
47217
47218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47219   void * jresult ;
47220   Dali::Vector< float > *arg1 = 0 ;
47221   Dali::Vector< float > *result = 0 ;
47222
47223   arg1 = (Dali::Vector< float > *)jarg1;
47224   if (!arg1) {
47225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47226     return 0;
47227   }
47228   {
47229     try {
47230       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245   jresult = (void *)result;
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47251   void * jresult ;
47252   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47253   Dali::Vector< float > *arg2 = 0 ;
47254   Dali::Vector< float > *result = 0 ;
47255
47256   arg1 = (Dali::Vector< float > *)jarg1;
47257   arg2 = (Dali::Vector< float > *)jarg2;
47258   if (!arg2) {
47259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47260     return 0;
47261   }
47262   {
47263     try {
47264       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47265     } catch (std::out_of_range& e) {
47266       {
47267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (std::exception& e) {
47270       {
47271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47272       };
47273     } catch (...) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47276       };
47277     }
47278   }
47279   jresult = (void *)result;
47280   return jresult;
47281 }
47282
47283
47284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47285   void * jresult ;
47286   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47287   Dali::Vector< float >::Iterator result;
47288
47289   arg1 = (Dali::Vector< float > *)jarg1;
47290   {
47291     try {
47292       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47293     } catch (std::out_of_range& e) {
47294       {
47295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (std::exception& e) {
47298       {
47299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47300       };
47301     } catch (...) {
47302       {
47303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47304       };
47305     }
47306   }
47307   jresult = (void *)result;
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47313   void * jresult ;
47314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47315   Dali::Vector< float >::Iterator result;
47316
47317   arg1 = (Dali::Vector< float > *)jarg1;
47318   {
47319     try {
47320       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335   jresult = (void *)result;
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47341   void * jresult ;
47342   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47343   Dali::Vector< float >::SizeType arg2 ;
47344   Dali::Vector< float >::ItemType *result = 0 ;
47345
47346   arg1 = (Dali::Vector< float > *)jarg1;
47347   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47348   {
47349     try {
47350       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47358       };
47359     } catch (...) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47362       };
47363     }
47364   }
47365   jresult = (void *)result;
47366   return jresult;
47367 }
47368
47369
47370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47371   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47372   Dali::Vector< float >::ItemType *arg2 = 0 ;
47373   Dali::Vector< float >::ItemType temp2 ;
47374
47375   arg1 = (Dali::Vector< float > *)jarg1;
47376   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47377   arg2 = &temp2;
47378   {
47379     try {
47380       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47381     } catch (std::out_of_range& e) {
47382       {
47383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47384       };
47385     } catch (std::exception& e) {
47386       {
47387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47388       };
47389     } catch (...) {
47390       {
47391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47392       };
47393     }
47394   }
47395 }
47396
47397
47398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47399   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47400   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47401   Dali::Vector< float >::ItemType *arg3 = 0 ;
47402   Dali::Vector< float >::ItemType temp3 ;
47403
47404   arg1 = (Dali::Vector< float > *)jarg1;
47405   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47406   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47407   arg3 = &temp3;
47408   {
47409     try {
47410       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47411     } catch (std::out_of_range& e) {
47412       {
47413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47414       };
47415     } catch (std::exception& e) {
47416       {
47417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47418       };
47419     } catch (...) {
47420       {
47421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47422       };
47423     }
47424   }
47425 }
47426
47427
47428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47429   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47430   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47431   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47432   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47433
47434   arg1 = (Dali::Vector< float > *)jarg1;
47435   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47436   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47437   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47438   {
47439     try {
47440       (arg1)->Insert(arg2,arg3,arg4);
47441     } catch (std::out_of_range& e) {
47442       {
47443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47444       };
47445     } catch (std::exception& e) {
47446       {
47447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47448       };
47449     } catch (...) {
47450       {
47451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47452       };
47453     }
47454   }
47455 }
47456
47457
47458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47460   Dali::Vector< float >::SizeType arg2 ;
47461
47462   arg1 = (Dali::Vector< float > *)jarg1;
47463   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47464   {
47465     try {
47466       (arg1)->Reserve(arg2);
47467     } catch (std::out_of_range& e) {
47468       {
47469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47470       };
47471     } catch (std::exception& e) {
47472       {
47473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47474       };
47475     } catch (...) {
47476       {
47477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47478       };
47479     }
47480   }
47481 }
47482
47483
47484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47485   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47486   Dali::Vector< float >::SizeType arg2 ;
47487
47488   arg1 = (Dali::Vector< float > *)jarg1;
47489   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47490   {
47491     try {
47492       (arg1)->Resize(arg2);
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47504       };
47505     }
47506   }
47507 }
47508
47509
47510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47511   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47512   Dali::Vector< float >::SizeType arg2 ;
47513   Dali::Vector< float >::ItemType *arg3 = 0 ;
47514   Dali::Vector< float >::ItemType temp3 ;
47515
47516   arg1 = (Dali::Vector< float > *)jarg1;
47517   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47518   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47519   arg3 = &temp3;
47520   {
47521     try {
47522       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47523     } catch (std::out_of_range& e) {
47524       {
47525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47526       };
47527     } catch (std::exception& e) {
47528       {
47529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (...) {
47532       {
47533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47534       };
47535     }
47536   }
47537 }
47538
47539
47540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47541   void * jresult ;
47542   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47543   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47544   Dali::Vector< float >::Iterator result;
47545
47546   arg1 = (Dali::Vector< float > *)jarg1;
47547   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47548   {
47549     try {
47550       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47551     } catch (std::out_of_range& e) {
47552       {
47553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47554       };
47555     } catch (std::exception& e) {
47556       {
47557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47558       };
47559     } catch (...) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47562       };
47563     }
47564   }
47565   jresult = (void *)result;
47566   return jresult;
47567 }
47568
47569
47570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47571   void * jresult ;
47572   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47573   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47574   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47575   Dali::Vector< float >::Iterator result;
47576
47577   arg1 = (Dali::Vector< float > *)jarg1;
47578   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47579   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47580   {
47581     try {
47582       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47583     } catch (std::out_of_range& e) {
47584       {
47585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (std::exception& e) {
47588       {
47589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47590       };
47591     } catch (...) {
47592       {
47593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47594       };
47595     }
47596   }
47597   jresult = (void *)result;
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47603   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47604   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47605
47606   arg1 = (Dali::Vector< float > *)jarg1;
47607   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47608   {
47609     try {
47610       (arg1)->Remove(arg2);
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47618       };
47619     } catch (...) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47622       };
47623     }
47624   }
47625 }
47626
47627
47628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47629   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47630   Dali::Vector< float > *arg2 = 0 ;
47631
47632   arg1 = (Dali::Vector< float > *)jarg1;
47633   arg2 = (Dali::Vector< float > *)jarg2;
47634   if (!arg2) {
47635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47636     return ;
47637   }
47638   {
47639     try {
47640       (arg1)->Swap(*arg2);
47641     } catch (std::out_of_range& e) {
47642       {
47643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47644       };
47645     } catch (std::exception& e) {
47646       {
47647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47648       };
47649     } catch (...) {
47650       {
47651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47652       };
47653     }
47654   }
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47659   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47660
47661   arg1 = (Dali::Vector< float > *)jarg1;
47662   {
47663     try {
47664       (arg1)->Clear();
47665     } catch (std::out_of_range& e) {
47666       {
47667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47668       };
47669     } catch (std::exception& e) {
47670       {
47671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47672       };
47673     } catch (...) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47676       };
47677     }
47678   }
47679 }
47680
47681
47682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47683   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47684
47685   arg1 = (Dali::Vector< float > *)jarg1;
47686   {
47687     try {
47688       (arg1)->Release();
47689     } catch (std::out_of_range& e) {
47690       {
47691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47692       };
47693     } catch (std::exception& e) {
47694       {
47695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47700       };
47701     }
47702   }
47703 }
47704
47705
47706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47707   int jresult ;
47708   int result;
47709
47710   result = (int)Dali::Vector< unsigned char >::BaseType;
47711   jresult = (int)result;
47712   return jresult;
47713 }
47714
47715
47716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47717   void * jresult ;
47718   Dali::Vector< unsigned char > *result = 0 ;
47719
47720   {
47721     try {
47722       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47723     } catch (std::out_of_range& e) {
47724       {
47725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47726       };
47727     } catch (std::exception& e) {
47728       {
47729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47730       };
47731     } catch (...) {
47732       {
47733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47734       };
47735     }
47736   }
47737   jresult = (void *)result;
47738   return jresult;
47739 }
47740
47741
47742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47743   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47744
47745   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47746   {
47747     try {
47748       delete arg1;
47749     } catch (std::out_of_range& e) {
47750       {
47751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47752       };
47753     } catch (std::exception& e) {
47754       {
47755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47756       };
47757     } catch (...) {
47758       {
47759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47760       };
47761     }
47762   }
47763 }
47764
47765
47766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47767   void * jresult ;
47768   Dali::Vector< unsigned char > *arg1 = 0 ;
47769   Dali::Vector< unsigned char > *result = 0 ;
47770
47771   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47772   if (!arg1) {
47773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47774     return 0;
47775   }
47776   {
47777     try {
47778       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47779     } catch (std::out_of_range& e) {
47780       {
47781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47782       };
47783     } catch (std::exception& e) {
47784       {
47785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (...) {
47788       {
47789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47790       };
47791     }
47792   }
47793   jresult = (void *)result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47799   void * jresult ;
47800   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47801   Dali::Vector< unsigned char > *arg2 = 0 ;
47802   Dali::Vector< unsigned char > *result = 0 ;
47803
47804   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47805   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47806   if (!arg2) {
47807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47808     return 0;
47809   }
47810   {
47811     try {
47812       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47813     } catch (std::out_of_range& e) {
47814       {
47815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (std::exception& e) {
47818       {
47819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47833   void * jresult ;
47834   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47835   Dali::Vector< unsigned char >::Iterator result;
47836
47837   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47838   {
47839     try {
47840       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47841     } catch (std::out_of_range& e) {
47842       {
47843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47844       };
47845     } catch (std::exception& e) {
47846       {
47847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (...) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47852       };
47853     }
47854   }
47855   jresult = (void *)result;
47856   return jresult;
47857 }
47858
47859
47860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47861   void * jresult ;
47862   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47863   Dali::Vector< unsigned char >::Iterator result;
47864
47865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47866   {
47867     try {
47868       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47869     } catch (std::out_of_range& e) {
47870       {
47871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47872       };
47873     } catch (std::exception& e) {
47874       {
47875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (...) {
47878       {
47879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47880       };
47881     }
47882   }
47883   jresult = (void *)result;
47884   return jresult;
47885 }
47886
47887
47888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47889   void * jresult ;
47890   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47891   Dali::Vector< unsigned char >::SizeType arg2 ;
47892   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47893
47894   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47895   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47896   {
47897     try {
47898       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47899     } catch (std::out_of_range& e) {
47900       {
47901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47902       };
47903     } catch (std::exception& e) {
47904       {
47905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47906       };
47907     } catch (...) {
47908       {
47909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47910       };
47911     }
47912   }
47913   jresult = (void *)result;
47914   return jresult;
47915 }
47916
47917
47918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47919   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47920   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47921   Dali::Vector< unsigned char >::ItemType temp2 ;
47922
47923   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47924   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47925   arg2 = &temp2;
47926   {
47927     try {
47928       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47929     } catch (std::out_of_range& e) {
47930       {
47931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47932       };
47933     } catch (std::exception& e) {
47934       {
47935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47940       };
47941     }
47942   }
47943 }
47944
47945
47946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47947   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47948   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47949   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47950   Dali::Vector< unsigned char >::ItemType temp3 ;
47951
47952   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47953   arg2 = jarg2;
47954   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47955   arg3 = &temp3;
47956   {
47957     try {
47958       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47959     } catch (std::out_of_range& e) {
47960       {
47961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47962       };
47963     } catch (std::exception& e) {
47964       {
47965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47966       };
47967     } catch (...) {
47968       {
47969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47970       };
47971     }
47972   }
47973
47974
47975 }
47976
47977
47978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47980   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47981   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47982   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47983
47984   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47985   arg2 = jarg2;
47986   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47987   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47988   {
47989     try {
47990       (arg1)->Insert(arg2,arg3,arg4);
47991     } catch (std::out_of_range& e) {
47992       {
47993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (std::exception& e) {
47996       {
47997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47998       };
47999     } catch (...) {
48000       {
48001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48002       };
48003     }
48004   }
48005
48006
48007 }
48008
48009
48010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
48011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48012   Dali::Vector< unsigned char >::SizeType arg2 ;
48013
48014   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48015   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48016   {
48017     try {
48018       (arg1)->Reserve(arg2);
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48030       };
48031     }
48032   }
48033 }
48034
48035
48036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48037   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48038   Dali::Vector< unsigned char >::SizeType arg2 ;
48039
48040   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48041   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48042   {
48043     try {
48044       (arg1)->Resize(arg2);
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48056       };
48057     }
48058   }
48059 }
48060
48061
48062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
48063   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48064   Dali::Vector< unsigned char >::SizeType arg2 ;
48065   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48066   Dali::Vector< unsigned char >::ItemType temp3 ;
48067
48068   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48069   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48070   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48071   arg3 = &temp3;
48072   {
48073     try {
48074       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48075     } catch (std::out_of_range& e) {
48076       {
48077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48078       };
48079     } catch (std::exception& e) {
48080       {
48081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48082       };
48083     } catch (...) {
48084       {
48085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48086       };
48087     }
48088   }
48089 }
48090
48091
48092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48093   void * jresult ;
48094   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48095   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48096   Dali::Vector< unsigned char >::Iterator result;
48097
48098   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48099   arg2 = jarg2;
48100   {
48101     try {
48102       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48103     } catch (std::out_of_range& e) {
48104       {
48105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48106       };
48107     } catch (std::exception& e) {
48108       {
48109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (...) {
48112       {
48113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48114       };
48115     }
48116   }
48117   jresult = (void *)result;
48118
48119
48120   return jresult;
48121 }
48122
48123
48124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48125   void * jresult ;
48126   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48127   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48128   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48129   Dali::Vector< unsigned char >::Iterator result;
48130
48131   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48132   arg2 = jarg2;
48133   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48134   {
48135     try {
48136       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (...) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48148       };
48149     }
48150   }
48151   jresult = (void *)result;
48152
48153
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48159   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48160   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48161
48162   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48163   arg2 = jarg2;
48164   {
48165     try {
48166       (arg1)->Remove(arg2);
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (...) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48178       };
48179     }
48180   }
48181
48182
48183 }
48184
48185
48186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48187   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48188   Dali::Vector< unsigned char > *arg2 = 0 ;
48189
48190   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48191   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48192   if (!arg2) {
48193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48194     return ;
48195   }
48196   {
48197     try {
48198       (arg1)->Swap(*arg2);
48199     } catch (std::out_of_range& e) {
48200       {
48201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48202       };
48203     } catch (std::exception& e) {
48204       {
48205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48206       };
48207     } catch (...) {
48208       {
48209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48210       };
48211     }
48212   }
48213 }
48214
48215
48216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48217   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48218
48219   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48220   {
48221     try {
48222       (arg1)->Clear();
48223     } catch (std::out_of_range& e) {
48224       {
48225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48226       };
48227     } catch (std::exception& e) {
48228       {
48229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (...) {
48232       {
48233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48234       };
48235     }
48236   }
48237 }
48238
48239
48240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48241   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48242
48243   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48244   {
48245     try {
48246       (arg1)->Release();
48247     } catch (std::out_of_range& e) {
48248       {
48249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (std::exception& e) {
48252       {
48253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48254       };
48255     } catch (...) {
48256       {
48257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48258       };
48259     }
48260   }
48261 }
48262
48263
48264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48265   int jresult ;
48266   int result;
48267
48268   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48269   jresult = (int)result;
48270   return jresult;
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48275   void * jresult ;
48276   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48277
48278   {
48279     try {
48280       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48281     } catch (std::out_of_range& e) {
48282       {
48283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48284       };
48285     } catch (std::exception& e) {
48286       {
48287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48288       };
48289     } catch (...) {
48290       {
48291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48292       };
48293     }
48294   }
48295   jresult = (void *)result;
48296   return jresult;
48297 }
48298
48299
48300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48302
48303   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48304   {
48305     try {
48306       delete arg1;
48307     } catch (std::out_of_range& e) {
48308       {
48309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48310       };
48311     } catch (std::exception& e) {
48312       {
48313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48314       };
48315     } catch (...) {
48316       {
48317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48318       };
48319     }
48320   }
48321 }
48322
48323
48324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48325   void * jresult ;
48326   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48327   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48328
48329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48330   if (!arg1) {
48331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48332     return 0;
48333   }
48334   {
48335     try {
48336       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48337     } catch (std::out_of_range& e) {
48338       {
48339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48340       };
48341     } catch (std::exception& e) {
48342       {
48343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48344       };
48345     } catch (...) {
48346       {
48347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48348       };
48349     }
48350   }
48351   jresult = (void *)result;
48352   return jresult;
48353 }
48354
48355
48356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48357   void * jresult ;
48358   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48359   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48360   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48361
48362   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48363   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48364   if (!arg2) {
48365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48366     return 0;
48367   }
48368   {
48369     try {
48370       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48371     } catch (std::out_of_range& e) {
48372       {
48373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48374       };
48375     } catch (std::exception& e) {
48376       {
48377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48378       };
48379     } catch (...) {
48380       {
48381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48382       };
48383     }
48384   }
48385   jresult = (void *)result;
48386   return jresult;
48387 }
48388
48389
48390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48391   void * jresult ;
48392   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48393   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48394
48395   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48396   {
48397     try {
48398       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48399     } catch (std::out_of_range& e) {
48400       {
48401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48402       };
48403     } catch (std::exception& e) {
48404       {
48405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48406       };
48407     } catch (...) {
48408       {
48409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48410       };
48411     }
48412   }
48413   jresult = (void *)result;
48414   return jresult;
48415 }
48416
48417
48418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48419   void * jresult ;
48420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48421   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48422
48423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48424   {
48425     try {
48426       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48427     } catch (std::out_of_range& e) {
48428       {
48429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48430       };
48431     } catch (std::exception& e) {
48432       {
48433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48438       };
48439     }
48440   }
48441   jresult = (void *)result;
48442   return jresult;
48443 }
48444
48445
48446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48447   void * jresult ;
48448   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48449   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48450   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48451
48452   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48453   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48454   {
48455     try {
48456       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48457     } catch (std::out_of_range& e) {
48458       {
48459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48460       };
48461     } catch (std::exception& e) {
48462       {
48463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48464       };
48465     } catch (...) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48468       };
48469     }
48470   }
48471   jresult = (void *)result;
48472   return jresult;
48473 }
48474
48475
48476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48477   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48478   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48479
48480   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48481   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48482   if (!arg2) {
48483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48484     return ;
48485   }
48486   {
48487     try {
48488       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
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 void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48507   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48508   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48509   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48510
48511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48512   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48513   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48514   if (!arg3) {
48515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48516     return ;
48517   }
48518   {
48519     try {
48520       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535 }
48536
48537
48538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48539   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48540   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48541   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48542   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48543
48544   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48545   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48546   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48547   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48548   {
48549     try {
48550       (arg1)->Insert(arg2,arg3,arg4);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (...) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48562       };
48563     }
48564   }
48565 }
48566
48567
48568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48569   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48570   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48571
48572   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48573   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48574   {
48575     try {
48576       (arg1)->Reserve(arg2);
48577     } catch (std::out_of_range& e) {
48578       {
48579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48580       };
48581     } catch (std::exception& e) {
48582       {
48583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48584       };
48585     } catch (...) {
48586       {
48587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48588       };
48589     }
48590   }
48591 }
48592
48593
48594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48595   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48596   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48597
48598   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48599   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48600   {
48601     try {
48602       (arg1)->Resize(arg2);
48603     } catch (std::out_of_range& e) {
48604       {
48605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (std::exception& e) {
48608       {
48609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617 }
48618
48619
48620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48621   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48622   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48623   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48624
48625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48626   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48627   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48628   if (!arg3) {
48629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48630     return ;
48631   }
48632   {
48633     try {
48634       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48635     } catch (std::out_of_range& e) {
48636       {
48637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48638       };
48639     } catch (std::exception& e) {
48640       {
48641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (...) {
48644       {
48645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48646       };
48647     }
48648   }
48649 }
48650
48651
48652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48653   void * jresult ;
48654   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48655   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48656   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48657
48658   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48659   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48660   {
48661     try {
48662       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
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_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48683   void * jresult ;
48684   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48685   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48686   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48687   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48688
48689   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48690   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48691   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48692   {
48693     try {
48694       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48695     } catch (std::out_of_range& e) {
48696       {
48697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48698       };
48699     } catch (std::exception& e) {
48700       {
48701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48702       };
48703     } catch (...) {
48704       {
48705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48706       };
48707     }
48708   }
48709   jresult = (void *)result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48715   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48716   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48717
48718   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48719   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48720   {
48721     try {
48722       (arg1)->Remove(arg2);
48723     } catch (std::out_of_range& e) {
48724       {
48725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48726       };
48727     } catch (std::exception& e) {
48728       {
48729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48730       };
48731     } catch (...) {
48732       {
48733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48734       };
48735     }
48736   }
48737 }
48738
48739
48740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48741   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48742   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48743
48744   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48745   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48746   if (!arg2) {
48747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48748     return ;
48749   }
48750   {
48751     try {
48752       (arg1)->Swap(*arg2);
48753     } catch (std::out_of_range& e) {
48754       {
48755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (std::exception& e) {
48758       {
48759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48760       };
48761     } catch (...) {
48762       {
48763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48764       };
48765     }
48766   }
48767 }
48768
48769
48770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48771   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48772
48773   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48774   {
48775     try {
48776       (arg1)->Clear();
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48784       };
48785     } catch (...) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48788       };
48789     }
48790   }
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48795   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48796
48797   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48798   {
48799     try {
48800       (arg1)->Release();
48801     } catch (std::out_of_range& e) {
48802       {
48803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48804       };
48805     } catch (std::exception& e) {
48806       {
48807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48808       };
48809     } catch (...) {
48810       {
48811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48812       };
48813     }
48814   }
48815 }
48816
48817
48818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48819   void * jresult ;
48820   Dali::Signal< void () > *result = 0 ;
48821
48822   {
48823     try {
48824       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48825     } catch (std::out_of_range& e) {
48826       {
48827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48828       };
48829     } catch (std::exception& e) {
48830       {
48831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48836       };
48837     }
48838   }
48839   jresult = (void *)result;
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48845   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48846
48847   arg1 = (Dali::Signal< void () > *)jarg1;
48848   {
48849     try {
48850       delete arg1;
48851     } catch (std::out_of_range& e) {
48852       {
48853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48854       };
48855     } catch (std::exception& e) {
48856       {
48857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48858       };
48859     } catch (...) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48862       };
48863     }
48864   }
48865 }
48866
48867
48868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48869   unsigned int jresult ;
48870   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48871   bool result;
48872
48873   arg1 = (Dali::Signal< void () > *)jarg1;
48874   {
48875     try {
48876       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48877     } catch (std::out_of_range& e) {
48878       {
48879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48880       };
48881     } catch (std::exception& e) {
48882       {
48883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48884       };
48885     } catch (...) {
48886       {
48887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48888       };
48889     }
48890   }
48891   jresult = result;
48892   return jresult;
48893 }
48894
48895
48896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48897   unsigned long jresult ;
48898   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48899   std::size_t result;
48900
48901   arg1 = (Dali::Signal< void () > *)jarg1;
48902   {
48903     try {
48904       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
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 = (unsigned long)result;
48920   return jresult;
48921 }
48922
48923
48924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48925   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48926   void (*arg2)() = (void (*)()) 0 ;
48927
48928   arg1 = (Dali::Signal< void () > *)jarg1;
48929   arg2 = (void (*)())jarg2;
48930   {
48931     try {
48932       (arg1)->Connect(arg2);
48933     } catch (std::out_of_range& e) {
48934       {
48935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48936       };
48937     } catch (std::exception& e) {
48938       {
48939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48940       };
48941     } catch (...) {
48942       {
48943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48944       };
48945     }
48946   }
48947 }
48948
48949
48950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48951   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48952   void (*arg2)() = (void (*)()) 0 ;
48953
48954   arg1 = (Dali::Signal< void () > *)jarg1;
48955   arg2 = (void (*)())jarg2;
48956   {
48957     try {
48958       (arg1)->Disconnect(arg2);
48959     } catch (std::out_of_range& e) {
48960       {
48961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48962       };
48963     } catch (std::exception& e) {
48964       {
48965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48970       };
48971     }
48972   }
48973 }
48974
48975
48976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48977   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48978   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48979   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48980
48981   arg1 = (Dali::Signal< void () > *)jarg1;
48982   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48983   arg3 = (Dali::FunctorDelegate *)jarg3;
48984   {
48985     try {
48986       (arg1)->Connect(arg2,arg3);
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_VoidSignal_Emit(void * jarg1) {
49005   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49006
49007   arg1 = (Dali::Signal< void () > *)jarg1;
49008   {
49009     try {
49010       (arg1)->Emit();
49011     } catch (std::out_of_range& e) {
49012       {
49013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49014       };
49015     } catch (std::exception& e) {
49016       {
49017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49018       };
49019     } catch (...) {
49020       {
49021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49022       };
49023     }
49024   }
49025 }
49026
49027
49028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
49029   unsigned int jresult ;
49030   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49031   bool result;
49032
49033   arg1 = (Dali::Signal< void (float) > *)jarg1;
49034   {
49035     try {
49036       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
49037     } catch (std::out_of_range& e) {
49038       {
49039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49040       };
49041     } catch (std::exception& e) {
49042       {
49043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49044       };
49045     } catch (...) {
49046       {
49047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49048       };
49049     }
49050   }
49051   jresult = result;
49052   return jresult;
49053 }
49054
49055
49056 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
49057   unsigned long jresult ;
49058   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49059   std::size_t result;
49060
49061   arg1 = (Dali::Signal< void (float) > *)jarg1;
49062   {
49063     try {
49064       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (...) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49076       };
49077     }
49078   }
49079   jresult = (unsigned long)result;
49080   return jresult;
49081 }
49082
49083
49084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49085   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49086   void (*arg2)(float) = (void (*)(float)) 0 ;
49087
49088   arg1 = (Dali::Signal< void (float) > *)jarg1;
49089   arg2 = (void (*)(float))jarg2;
49090   {
49091     try {
49092       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49093     } catch (std::out_of_range& e) {
49094       {
49095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49096       };
49097     } catch (std::exception& e) {
49098       {
49099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49100       };
49101     } catch (...) {
49102       {
49103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49104       };
49105     }
49106   }
49107 }
49108
49109
49110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49111   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49112   void (*arg2)(float) = (void (*)(float)) 0 ;
49113
49114   arg1 = (Dali::Signal< void (float) > *)jarg1;
49115   arg2 = (void (*)(float))jarg2;
49116   {
49117     try {
49118       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49119     } catch (std::out_of_range& e) {
49120       {
49121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49122       };
49123     } catch (std::exception& e) {
49124       {
49125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49126       };
49127     } catch (...) {
49128       {
49129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49130       };
49131     }
49132   }
49133 }
49134
49135
49136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49137   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49138   float arg2 ;
49139
49140   arg1 = (Dali::Signal< void (float) > *)jarg1;
49141   arg2 = (float)jarg2;
49142   {
49143     try {
49144       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49145     } catch (std::out_of_range& e) {
49146       {
49147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49148       };
49149     } catch (std::exception& e) {
49150       {
49151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (...) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49156       };
49157     }
49158   }
49159 }
49160
49161
49162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49163   void * jresult ;
49164   Dali::Signal< void (float) > *result = 0 ;
49165
49166   {
49167     try {
49168       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49169     } catch (std::out_of_range& e) {
49170       {
49171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (std::exception& e) {
49174       {
49175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49180       };
49181     }
49182   }
49183   jresult = (void *)result;
49184   return jresult;
49185 }
49186
49187
49188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49189   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49190
49191   arg1 = (Dali::Signal< void (float) > *)jarg1;
49192   {
49193     try {
49194       delete arg1;
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49202       };
49203     } catch (...) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49206       };
49207     }
49208   }
49209 }
49210
49211
49212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49213   unsigned int jresult ;
49214   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49215   bool result;
49216
49217   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49218   {
49219     try {
49220       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49221     } catch (std::out_of_range& e) {
49222       {
49223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49224       };
49225     } catch (std::exception& e) {
49226       {
49227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49228       };
49229     } catch (...) {
49230       {
49231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49232       };
49233     }
49234   }
49235   jresult = result;
49236   return jresult;
49237 }
49238
49239
49240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49241   unsigned long jresult ;
49242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49243   std::size_t result;
49244
49245   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49246   {
49247     try {
49248       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49249     } catch (std::out_of_range& e) {
49250       {
49251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49252       };
49253     } catch (std::exception& e) {
49254       {
49255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49260       };
49261     }
49262   }
49263   jresult = (unsigned long)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49269   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49270   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49271
49272   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49273   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49274   {
49275     try {
49276       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49284       };
49285     } catch (...) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49288       };
49289     }
49290   }
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49295   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49296   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49297
49298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49299   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49300   {
49301     try {
49302       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (...) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49314       };
49315     }
49316   }
49317 }
49318
49319
49320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49321   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49322   Dali::BaseHandle arg2 ;
49323   Dali::BaseHandle *argp2 ;
49324
49325   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49326   argp2 = (Dali::BaseHandle *)jarg2;
49327   if (!argp2) {
49328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49329     return ;
49330   }
49331   arg2 = *argp2;
49332   {
49333     try {
49334       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49335     } catch (std::out_of_range& e) {
49336       {
49337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49338       };
49339     } catch (std::exception& e) {
49340       {
49341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49342       };
49343     } catch (...) {
49344       {
49345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49346       };
49347     }
49348   }
49349 }
49350
49351
49352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49353   void * jresult ;
49354   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49355
49356   {
49357     try {
49358       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49359     } catch (std::out_of_range& e) {
49360       {
49361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49362       };
49363     } catch (std::exception& e) {
49364       {
49365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49366       };
49367     } catch (...) {
49368       {
49369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49370       };
49371     }
49372   }
49373   jresult = (void *)result;
49374   return jresult;
49375 }
49376
49377
49378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49379   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49380
49381   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49382   {
49383     try {
49384       delete arg1;
49385     } catch (std::out_of_range& e) {
49386       {
49387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49388       };
49389     } catch (std::exception& e) {
49390       {
49391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49392       };
49393     } catch (...) {
49394       {
49395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49396       };
49397     }
49398   }
49399 }
49400
49401
49402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49403   unsigned int jresult ;
49404   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49405   bool result;
49406
49407   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49408   {
49409     try {
49410       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425   jresult = result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49431   unsigned long jresult ;
49432   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49433   std::size_t result;
49434
49435   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49436   {
49437     try {
49438       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49439     } catch (std::out_of_range& e) {
49440       {
49441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49442       };
49443     } catch (std::exception& e) {
49444       {
49445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (...) {
49448       {
49449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49450       };
49451     }
49452   }
49453   jresult = (unsigned long)result;
49454   return jresult;
49455 }
49456
49457
49458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49459   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49460   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49461
49462   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49463   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49464   {
49465     try {
49466       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49467     } catch (std::out_of_range& e) {
49468       {
49469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49470       };
49471     } catch (std::exception& e) {
49472       {
49473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49474       };
49475     } catch (...) {
49476       {
49477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49478       };
49479     }
49480   }
49481 }
49482
49483
49484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49485   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49486   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49487
49488   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49489   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49490   {
49491     try {
49492       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49500       };
49501     } catch (...) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49504       };
49505     }
49506   }
49507 }
49508
49509
49510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49511   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49512   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49513
49514   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49515   arg2 = (Dali::RefObject *)jarg2;
49516   {
49517     try {
49518       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49519     } catch (std::out_of_range& e) {
49520       {
49521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49522       };
49523     } catch (std::exception& e) {
49524       {
49525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49530       };
49531     }
49532   }
49533 }
49534
49535
49536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49537   void * jresult ;
49538   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49539
49540   {
49541     try {
49542       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49550       };
49551     } catch (...) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49554       };
49555     }
49556   }
49557   jresult = (void *)result;
49558   return jresult;
49559 }
49560
49561
49562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49563   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49564
49565   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49566   {
49567     try {
49568       delete arg1;
49569     } catch (std::out_of_range& e) {
49570       {
49571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49572       };
49573     } catch (std::exception& e) {
49574       {
49575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49576       };
49577     } catch (...) {
49578       {
49579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49580       };
49581     }
49582   }
49583 }
49584
49585
49586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49587   unsigned int jresult ;
49588   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49589   bool result;
49590
49591   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49592   {
49593     try {
49594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49595     } catch (std::out_of_range& e) {
49596       {
49597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49598       };
49599     } catch (std::exception& e) {
49600       {
49601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49602       };
49603     } catch (...) {
49604       {
49605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49606       };
49607     }
49608   }
49609   jresult = result;
49610   return jresult;
49611 }
49612
49613
49614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49615   unsigned long jresult ;
49616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49617   std::size_t result;
49618
49619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49620   {
49621     try {
49622       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49623     } catch (std::out_of_range& e) {
49624       {
49625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (std::exception& e) {
49628       {
49629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637   jresult = (unsigned long)result;
49638   return jresult;
49639 }
49640
49641
49642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49643   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49644   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49645
49646   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49647   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49648   {
49649     try {
49650       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49651     } catch (std::out_of_range& e) {
49652       {
49653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49654       };
49655     } catch (std::exception& e) {
49656       {
49657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49658       };
49659     } catch (...) {
49660       {
49661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49662       };
49663     }
49664   }
49665 }
49666
49667
49668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49669   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49670   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49671
49672   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49673   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49674   {
49675     try {
49676       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691 }
49692
49693
49694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49695   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49696   Dali::PropertyNotification *arg2 = 0 ;
49697
49698   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49699   arg2 = (Dali::PropertyNotification *)jarg2;
49700   if (!arg2) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49702     return ;
49703   }
49704   {
49705     try {
49706       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49707     } catch (std::out_of_range& e) {
49708       {
49709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49710       };
49711     } catch (std::exception& e) {
49712       {
49713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (...) {
49716       {
49717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49718       };
49719     }
49720   }
49721 }
49722
49723
49724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49725   void * jresult ;
49726   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49727
49728   {
49729     try {
49730       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49731     } catch (std::out_of_range& e) {
49732       {
49733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (std::exception& e) {
49736       {
49737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (...) {
49740       {
49741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49742       };
49743     }
49744   }
49745   jresult = (void *)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49751   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49752
49753   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49754   {
49755     try {
49756       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49775   unsigned int jresult ;
49776   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49777   bool result;
49778
49779   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49780   {
49781     try {
49782       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (...) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49794       };
49795     }
49796   }
49797   jresult = result;
49798   return jresult;
49799 }
49800
49801
49802 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49803   unsigned long jresult ;
49804   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49805   std::size_t result;
49806
49807   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49808   {
49809     try {
49810       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49811     } catch (std::out_of_range& e) {
49812       {
49813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49814       };
49815     } catch (std::exception& e) {
49816       {
49817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (...) {
49820       {
49821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49822       };
49823     }
49824   }
49825   jresult = (unsigned long)result;
49826   return jresult;
49827 }
49828
49829
49830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49831   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49832   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49833
49834   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49835   arg2 = (void (*)(Dali::Image))jarg2;
49836   {
49837     try {
49838       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49839     } catch (std::out_of_range& e) {
49840       {
49841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49842       };
49843     } catch (std::exception& e) {
49844       {
49845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (...) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49850       };
49851     }
49852   }
49853 }
49854
49855
49856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49857   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49858   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49859
49860   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49861   arg2 = (void (*)(Dali::Image))jarg2;
49862   {
49863     try {
49864       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49865     } catch (std::out_of_range& e) {
49866       {
49867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49868       };
49869     } catch (std::exception& e) {
49870       {
49871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (...) {
49874       {
49875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49876       };
49877     }
49878   }
49879 }
49880
49881
49882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49883   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49884   Dali::Image arg2 ;
49885   Dali::Image *argp2 ;
49886
49887   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49888   argp2 = (Dali::Image *)jarg2;
49889   if (!argp2) {
49890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49891     return ;
49892   }
49893   arg2 = *argp2;
49894   {
49895     try {
49896       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49897     } catch (std::out_of_range& e) {
49898       {
49899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49900       };
49901     } catch (std::exception& e) {
49902       {
49903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49904       };
49905     } catch (...) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49908       };
49909     }
49910   }
49911 }
49912
49913
49914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49915   void * jresult ;
49916   Dali::Signal< void (Dali::Image) > *result = 0 ;
49917
49918   {
49919     try {
49920       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49921     } catch (std::out_of_range& e) {
49922       {
49923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49924       };
49925     } catch (std::exception& e) {
49926       {
49927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49928       };
49929     } catch (...) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49932       };
49933     }
49934   }
49935   jresult = (void *)result;
49936   return jresult;
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49941   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49942
49943   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49944   {
49945     try {
49946       delete arg1;
49947     } catch (std::out_of_range& e) {
49948       {
49949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49950       };
49951     } catch (std::exception& e) {
49952       {
49953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49954       };
49955     } catch (...) {
49956       {
49957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49958       };
49959     }
49960   }
49961 }
49962
49963
49964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49965   void * jresult ;
49966   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49967
49968   {
49969     try {
49970       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49971     } catch (std::out_of_range& e) {
49972       {
49973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (std::exception& e) {
49976       {
49977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49982       };
49983     }
49984   }
49985   jresult = (void *)result;
49986   return jresult;
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49991   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49992
49993   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49994   {
49995     try {
49996       delete arg1;
49997     } catch (std::out_of_range& e) {
49998       {
49999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (std::exception& e) {
50002       {
50003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011 }
50012
50013
50014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
50015   unsigned int jresult ;
50016   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50017   bool result;
50018
50019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50020   {
50021     try {
50022       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);
50023     } catch (std::out_of_range& e) {
50024       {
50025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50026       };
50027     } catch (std::exception& e) {
50028       {
50029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50030       };
50031     } catch (...) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50034       };
50035     }
50036   }
50037   jresult = result;
50038   return jresult;
50039 }
50040
50041
50042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50043   unsigned long jresult ;
50044   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50045   std::size_t result;
50046
50047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50048   {
50049     try {
50050       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);
50051     } catch (std::out_of_range& e) {
50052       {
50053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50054       };
50055     } catch (std::exception& e) {
50056       {
50057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50058       };
50059     } catch (...) {
50060       {
50061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50062       };
50063     }
50064   }
50065   jresult = (unsigned long)result;
50066   return jresult;
50067 }
50068
50069
50070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50071   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50072   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50073
50074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50075   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50076   {
50077     try {
50078       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (...) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50090       };
50091     }
50092   }
50093 }
50094
50095
50096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50097   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50098   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50099
50100   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50101   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50102   {
50103     try {
50104       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50105     } catch (std::out_of_range& e) {
50106       {
50107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50108       };
50109     } catch (std::exception& e) {
50110       {
50111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50116       };
50117     }
50118   }
50119 }
50120
50121
50122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50123   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50124   Dali::Actor arg2 ;
50125   Dali::LongPressGesture *arg3 = 0 ;
50126   Dali::Actor *argp2 ;
50127
50128   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50129   argp2 = (Dali::Actor *)jarg2;
50130   if (!argp2) {
50131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50132     return ;
50133   }
50134   arg2 = *argp2;
50135   arg3 = (Dali::LongPressGesture *)jarg3;
50136   if (!arg3) {
50137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50138     return ;
50139   }
50140   {
50141     try {
50142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50143     } catch (std::out_of_range& e) {
50144       {
50145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50146       };
50147     } catch (std::exception& e) {
50148       {
50149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50150       };
50151     } catch (...) {
50152       {
50153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50154       };
50155     }
50156   }
50157 }
50158
50159
50160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50161   void * jresult ;
50162   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50163
50164   {
50165     try {
50166       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50167     } catch (std::out_of_range& e) {
50168       {
50169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50170       };
50171     } catch (std::exception& e) {
50172       {
50173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (...) {
50176       {
50177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50178       };
50179     }
50180   }
50181   jresult = (void *)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50187   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50188
50189   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50190   {
50191     try {
50192       delete arg1;
50193     } catch (std::out_of_range& e) {
50194       {
50195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50196       };
50197     } catch (std::exception& e) {
50198       {
50199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50200       };
50201     } catch (...) {
50202       {
50203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50204       };
50205     }
50206   }
50207 }
50208
50209
50210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50211   unsigned int jresult ;
50212   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50213   bool result;
50214
50215   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50216   {
50217     try {
50218       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);
50219     } catch (std::out_of_range& e) {
50220       {
50221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50222       };
50223     } catch (std::exception& e) {
50224       {
50225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50226       };
50227     } catch (...) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50230       };
50231     }
50232   }
50233   jresult = result;
50234   return jresult;
50235 }
50236
50237
50238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50239   unsigned long jresult ;
50240   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50241   std::size_t result;
50242
50243   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50244   {
50245     try {
50246       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);
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (...) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50258       };
50259     }
50260   }
50261   jresult = (unsigned long)result;
50262   return jresult;
50263 }
50264
50265
50266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50267   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50268   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50269
50270   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50271   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50272   {
50273     try {
50274       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50275     } catch (std::out_of_range& e) {
50276       {
50277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50278       };
50279     } catch (std::exception& e) {
50280       {
50281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50282       };
50283     } catch (...) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50286       };
50287     }
50288   }
50289 }
50290
50291
50292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50293   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50294   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50295
50296   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50297   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50298   {
50299     try {
50300       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50301     } catch (std::out_of_range& e) {
50302       {
50303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50304       };
50305     } catch (std::exception& e) {
50306       {
50307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50308       };
50309     } catch (...) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50312       };
50313     }
50314   }
50315 }
50316
50317
50318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50319   unsigned int jresult ;
50320   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50321   Dali::Actor arg2 ;
50322   Dali::TouchData *arg3 = 0 ;
50323   Dali::Actor *argp2 ;
50324   bool result;
50325
50326   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50327   argp2 = (Dali::Actor *)jarg2;
50328   if (!argp2) {
50329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50330     return 0;
50331   }
50332   arg2 = *argp2;
50333   arg3 = (Dali::TouchData *)jarg3;
50334   if (!arg3) {
50335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50336     return 0;
50337   }
50338   {
50339     try {
50340       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50341     } catch (std::out_of_range& e) {
50342       {
50343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (std::exception& e) {
50346       {
50347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355   jresult = result;
50356   return jresult;
50357 }
50358
50359
50360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50361   void * jresult ;
50362   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50363
50364   {
50365     try {
50366       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (...) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50378       };
50379     }
50380   }
50381   jresult = (void *)result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50387   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50388
50389   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50390   {
50391     try {
50392       delete arg1;
50393     } catch (std::out_of_range& e) {
50394       {
50395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50396       };
50397     } catch (std::exception& e) {
50398       {
50399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50400       };
50401     } catch (...) {
50402       {
50403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50404       };
50405     }
50406   }
50407 }
50408
50409
50410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50411   unsigned int jresult ;
50412   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50413   bool result;
50414
50415   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50416   {
50417     try {
50418       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);
50419     } catch (std::out_of_range& e) {
50420       {
50421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50422       };
50423     } catch (std::exception& e) {
50424       {
50425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50426       };
50427     } catch (...) {
50428       {
50429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50430       };
50431     }
50432   }
50433   jresult = result;
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50439   unsigned long jresult ;
50440   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50441   std::size_t result;
50442
50443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50444   {
50445     try {
50446       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);
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (...) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50458       };
50459     }
50460   }
50461   jresult = (unsigned long)result;
50462   return jresult;
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50467   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50468   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50469
50470   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50471   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50472   {
50473     try {
50474       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50475     } catch (std::out_of_range& e) {
50476       {
50477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50478       };
50479     } catch (std::exception& e) {
50480       {
50481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50482       };
50483     } catch (...) {
50484       {
50485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50486       };
50487     }
50488   }
50489 }
50490
50491
50492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50493   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50494   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50495
50496   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50497   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50498   {
50499     try {
50500       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50501     } catch (std::out_of_range& e) {
50502       {
50503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50504       };
50505     } catch (std::exception& e) {
50506       {
50507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50508       };
50509     } catch (...) {
50510       {
50511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50512       };
50513     }
50514   }
50515 }
50516
50517
50518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50519   unsigned int jresult ;
50520   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50521   Dali::Actor arg2 ;
50522   Dali::HoverEvent *arg3 = 0 ;
50523   Dali::Actor *argp2 ;
50524   bool result;
50525
50526   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50527   argp2 = (Dali::Actor *)jarg2;
50528   if (!argp2) {
50529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50530     return 0;
50531   }
50532   arg2 = *argp2;
50533   arg3 = (Dali::HoverEvent *)jarg3;
50534   if (!arg3) {
50535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50536     return 0;
50537   }
50538   {
50539     try {
50540       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50541     } catch (std::out_of_range& e) {
50542       {
50543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50544       };
50545     } catch (std::exception& e) {
50546       {
50547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50548       };
50549     } catch (...) {
50550       {
50551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50552       };
50553     }
50554   }
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50561   void * jresult ;
50562   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50563
50564   {
50565     try {
50566       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50567     } catch (std::out_of_range& e) {
50568       {
50569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50570       };
50571     } catch (std::exception& e) {
50572       {
50573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (...) {
50576       {
50577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50578       };
50579     }
50580   }
50581   jresult = (void *)result;
50582   return jresult;
50583 }
50584
50585
50586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50587   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50588
50589   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50590   {
50591     try {
50592       delete arg1;
50593     } catch (std::out_of_range& e) {
50594       {
50595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50596       };
50597     } catch (std::exception& e) {
50598       {
50599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50600       };
50601     } catch (...) {
50602       {
50603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50604       };
50605     }
50606   }
50607 }
50608
50609
50610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50611   unsigned int jresult ;
50612   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50613   bool result;
50614
50615   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50616   {
50617     try {
50618       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);
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (...) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50630       };
50631     }
50632   }
50633   jresult = result;
50634   return jresult;
50635 }
50636
50637
50638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50639   unsigned long jresult ;
50640   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50641   std::size_t result;
50642
50643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50644   {
50645     try {
50646       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);
50647     } catch (std::out_of_range& e) {
50648       {
50649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50650       };
50651     } catch (std::exception& e) {
50652       {
50653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50654       };
50655     } catch (...) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50658       };
50659     }
50660   }
50661   jresult = (unsigned long)result;
50662   return jresult;
50663 }
50664
50665
50666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50667   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50668   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50669
50670   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50671   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50672   {
50673     try {
50674       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50675     } catch (std::out_of_range& e) {
50676       {
50677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50678       };
50679     } catch (std::exception& e) {
50680       {
50681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50682       };
50683     } catch (...) {
50684       {
50685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50686       };
50687     }
50688   }
50689 }
50690
50691
50692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50693   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50694   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50695
50696   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50697   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50698   {
50699     try {
50700       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50701     } catch (std::out_of_range& e) {
50702       {
50703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (std::exception& e) {
50706       {
50707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50708       };
50709     } catch (...) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50712       };
50713     }
50714   }
50715 }
50716
50717
50718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50719   unsigned int jresult ;
50720   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50721   Dali::Actor arg2 ;
50722   Dali::WheelEvent *arg3 = 0 ;
50723   Dali::Actor *argp2 ;
50724   bool result;
50725
50726   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50727   argp2 = (Dali::Actor *)jarg2;
50728   if (!argp2) {
50729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50730     return 0;
50731   }
50732   arg2 = *argp2;
50733   arg3 = (Dali::WheelEvent *)jarg3;
50734   if (!arg3) {
50735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50736     return 0;
50737   }
50738   {
50739     try {
50740       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50741     } catch (std::out_of_range& e) {
50742       {
50743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50744       };
50745     } catch (std::exception& e) {
50746       {
50747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50748       };
50749     } catch (...) {
50750       {
50751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50752       };
50753     }
50754   }
50755   jresult = result;
50756   return jresult;
50757 }
50758
50759
50760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50761   void * jresult ;
50762   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50763
50764   {
50765     try {
50766       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (...) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50778       };
50779     }
50780   }
50781   jresult = (void *)result;
50782   return jresult;
50783 }
50784
50785
50786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50787   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50788
50789   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50790   {
50791     try {
50792       delete arg1;
50793     } catch (std::out_of_range& e) {
50794       {
50795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (std::exception& e) {
50798       {
50799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50800       };
50801     } catch (...) {
50802       {
50803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50804       };
50805     }
50806   }
50807 }
50808
50809
50810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50811   unsigned int jresult ;
50812   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50813   bool result;
50814
50815   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50816   {
50817     try {
50818       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50819     } catch (std::out_of_range& e) {
50820       {
50821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50822       };
50823     } catch (std::exception& e) {
50824       {
50825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50826       };
50827     } catch (...) {
50828       {
50829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50830       };
50831     }
50832   }
50833   jresult = result;
50834   return jresult;
50835 }
50836
50837
50838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50839   unsigned long jresult ;
50840   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50841   std::size_t result;
50842
50843   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50844   {
50845     try {
50846       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50847     } catch (std::out_of_range& e) {
50848       {
50849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (std::exception& e) {
50852       {
50853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861   jresult = (unsigned long)result;
50862   return jresult;
50863 }
50864
50865
50866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50867   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50868   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50869
50870   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50871   arg2 = (void (*)(Dali::Actor))jarg2;
50872   {
50873     try {
50874       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50875     } catch (std::out_of_range& e) {
50876       {
50877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50878       };
50879     } catch (std::exception& e) {
50880       {
50881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50882       };
50883     } catch (...) {
50884       {
50885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50886       };
50887     }
50888   }
50889 }
50890
50891
50892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50894   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50897   arg2 = (void (*)(Dali::Actor))jarg2;
50898   {
50899     try {
50900       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50908       };
50909     } catch (...) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50912       };
50913     }
50914   }
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50919   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50920   Dali::Actor arg2 ;
50921   Dali::Actor *argp2 ;
50922
50923   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50924   argp2 = (Dali::Actor *)jarg2;
50925   if (!argp2) {
50926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50927     return ;
50928   }
50929   arg2 = *argp2;
50930   {
50931     try {
50932       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50933     } catch (std::out_of_range& e) {
50934       {
50935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50936       };
50937     } catch (std::exception& e) {
50938       {
50939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50940       };
50941     } catch (...) {
50942       {
50943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50944       };
50945     }
50946   }
50947 }
50948
50949
50950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50951   void * jresult ;
50952   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50953
50954   {
50955     try {
50956       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50957     } catch (std::out_of_range& e) {
50958       {
50959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50960       };
50961     } catch (std::exception& e) {
50962       {
50963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50964       };
50965     } catch (...) {
50966       {
50967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50968       };
50969     }
50970   }
50971   jresult = (void *)result;
50972   return jresult;
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50977   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50978
50979   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50980   {
50981     try {
50982       delete arg1;
50983     } catch (std::out_of_range& e) {
50984       {
50985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50986       };
50987     } catch (std::exception& e) {
50988       {
50989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50990       };
50991     } catch (...) {
50992       {
50993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50994       };
50995     }
50996   }
50997 }
50998
50999
51000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
51001   unsigned int jresult ;
51002   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51003   bool result;
51004
51005   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51006   {
51007     try {
51008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51009     } catch (std::out_of_range& e) {
51010       {
51011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (std::exception& e) {
51014       {
51015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (...) {
51018       {
51019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51020       };
51021     }
51022   }
51023   jresult = result;
51024   return jresult;
51025 }
51026
51027
51028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
51029   unsigned long jresult ;
51030   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51031   std::size_t result;
51032
51033   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51034   {
51035     try {
51036       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51044       };
51045     } catch (...) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51048       };
51049     }
51050   }
51051   jresult = (unsigned long)result;
51052   return jresult;
51053 }
51054
51055
51056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
51057   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51058   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51059
51060   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51061   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51062   {
51063     try {
51064       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51076       };
51077     }
51078   }
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51083   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51084   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51085
51086   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51087   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51088   {
51089     try {
51090       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51091     } catch (std::out_of_range& e) {
51092       {
51093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51094       };
51095     } catch (std::exception& e) {
51096       {
51097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51098       };
51099     } catch (...) {
51100       {
51101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51102       };
51103     }
51104   }
51105 }
51106
51107
51108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51109   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51110   Dali::KeyEvent *arg2 = 0 ;
51111
51112   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51113   arg2 = (Dali::KeyEvent *)jarg2;
51114   if (!arg2) {
51115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51116     return ;
51117   }
51118   {
51119     try {
51120       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51128       };
51129     } catch (...) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51132       };
51133     }
51134   }
51135 }
51136
51137
51138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51139   void * jresult ;
51140   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51141
51142   {
51143     try {
51144       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51145     } catch (std::out_of_range& e) {
51146       {
51147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51148       };
51149     } catch (std::exception& e) {
51150       {
51151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51156       };
51157     }
51158   }
51159   jresult = (void *)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51165   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51166
51167   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51168   {
51169     try {
51170       delete arg1;
51171     } catch (std::out_of_range& e) {
51172       {
51173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51174       };
51175     } catch (std::exception& e) {
51176       {
51177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51178       };
51179     } catch (...) {
51180       {
51181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51182       };
51183     }
51184   }
51185 }
51186
51187
51188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51189   unsigned int jresult ;
51190   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51191   bool result;
51192
51193   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51194   {
51195     try {
51196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51197     } catch (std::out_of_range& e) {
51198       {
51199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51200       };
51201     } catch (std::exception& e) {
51202       {
51203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51204       };
51205     } catch (...) {
51206       {
51207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51208       };
51209     }
51210   }
51211   jresult = result;
51212   return jresult;
51213 }
51214
51215
51216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51217   unsigned long jresult ;
51218   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51219   std::size_t result;
51220
51221   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51222   {
51223     try {
51224       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51225     } catch (std::out_of_range& e) {
51226       {
51227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (std::exception& e) {
51230       {
51231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51236       };
51237     }
51238   }
51239   jresult = (unsigned long)result;
51240   return jresult;
51241 }
51242
51243
51244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51245   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51246   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51247
51248   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51249   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51250   {
51251     try {
51252       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51253     } catch (std::out_of_range& e) {
51254       {
51255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51256       };
51257     } catch (std::exception& e) {
51258       {
51259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51260       };
51261     } catch (...) {
51262       {
51263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51264       };
51265     }
51266   }
51267 }
51268
51269
51270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51271   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51272   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51273
51274   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51275   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51276   {
51277     try {
51278       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293 }
51294
51295
51296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51297   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51298   Dali::TouchData *arg2 = 0 ;
51299
51300   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51301   arg2 = (Dali::TouchData *)jarg2;
51302   if (!arg2) {
51303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51304     return ;
51305   }
51306   {
51307     try {
51308       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51309     } catch (std::out_of_range& e) {
51310       {
51311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51312       };
51313     } catch (std::exception& e) {
51314       {
51315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51320       };
51321     }
51322   }
51323 }
51324
51325
51326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51327   void * jresult ;
51328   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51329
51330   {
51331     try {
51332       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51333     } catch (std::out_of_range& e) {
51334       {
51335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51336       };
51337     } catch (std::exception& e) {
51338       {
51339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (...) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51344       };
51345     }
51346   }
51347   jresult = (void *)result;
51348   return jresult;
51349 }
51350
51351
51352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51353   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51354
51355   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51356   {
51357     try {
51358       delete arg1;
51359     } catch (std::out_of_range& e) {
51360       {
51361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51362       };
51363     } catch (std::exception& e) {
51364       {
51365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51366       };
51367     } catch (...) {
51368       {
51369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51370       };
51371     }
51372   }
51373 }
51374
51375
51376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51377   unsigned int jresult ;
51378   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51379   bool result;
51380
51381   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51382   {
51383     try {
51384       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51385     } catch (std::out_of_range& e) {
51386       {
51387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51388       };
51389     } catch (std::exception& e) {
51390       {
51391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51392       };
51393     } catch (...) {
51394       {
51395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51396       };
51397     }
51398   }
51399   jresult = result;
51400   return jresult;
51401 }
51402
51403
51404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51405   unsigned long jresult ;
51406   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51407   std::size_t result;
51408
51409   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51410   {
51411     try {
51412       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51413     } catch (std::out_of_range& e) {
51414       {
51415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51416       };
51417     } catch (std::exception& e) {
51418       {
51419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51424       };
51425     }
51426   }
51427   jresult = (unsigned long)result;
51428   return jresult;
51429 }
51430
51431
51432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51433   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51434   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51435
51436   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51437   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51438   {
51439     try {
51440       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (...) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51452       };
51453     }
51454   }
51455 }
51456
51457
51458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51459   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51460   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51461
51462   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51463   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51464   {
51465     try {
51466       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51467     } catch (std::out_of_range& e) {
51468       {
51469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (std::exception& e) {
51472       {
51473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481 }
51482
51483
51484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51485   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51486   Dali::WheelEvent *arg2 = 0 ;
51487
51488   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51489   arg2 = (Dali::WheelEvent *)jarg2;
51490   if (!arg2) {
51491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51492     return ;
51493   }
51494   {
51495     try {
51496       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51497     } catch (std::out_of_range& e) {
51498       {
51499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (std::exception& e) {
51502       {
51503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511 }
51512
51513
51514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51515   void * jresult ;
51516   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51517
51518   {
51519     try {
51520       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51532       };
51533     }
51534   }
51535   jresult = (void *)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51541   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51542
51543   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51544   {
51545     try {
51546       delete arg1;
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51558       };
51559     }
51560   }
51561 }
51562
51563
51564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51565   void * jresult ;
51566   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51567
51568   {
51569     try {
51570       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51571     } catch (std::out_of_range& e) {
51572       {
51573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51574       };
51575     } catch (std::exception& e) {
51576       {
51577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51578       };
51579     } catch (...) {
51580       {
51581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51582       };
51583     }
51584   }
51585   jresult = (void *)result;
51586   return jresult;
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51591   void * jresult ;
51592   Dali::Radian arg1 ;
51593   Dali::Radian arg2 ;
51594   Dali::Radian *argp1 ;
51595   Dali::Radian *argp2 ;
51596   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51597
51598   argp1 = (Dali::Radian *)jarg1;
51599   if (!argp1) {
51600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51601     return 0;
51602   }
51603   arg1 = *argp1;
51604   argp2 = (Dali::Radian *)jarg2;
51605   if (!argp2) {
51606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51607     return 0;
51608   }
51609   arg2 = *argp2;
51610   {
51611     try {
51612       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (...) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51624       };
51625     }
51626   }
51627   jresult = (void *)result;
51628   return jresult;
51629 }
51630
51631
51632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51633   void * jresult ;
51634   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51635   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51636
51637   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51638   if (!arg1) {
51639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51640     return 0;
51641   }
51642   {
51643     try {
51644       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
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 = (void *)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51665   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51666   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51667
51668   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51669   arg2 = (Dali::Radian *)jarg2;
51670   if (arg1) (arg1)->first = *arg2;
51671 }
51672
51673
51674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51675   void * jresult ;
51676   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51677   Dali::Radian *result = 0 ;
51678
51679   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51680   result = (Dali::Radian *)& ((arg1)->first);
51681   jresult = (void *)result;
51682   return jresult;
51683 }
51684
51685
51686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51687   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51688   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51689
51690   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51691   arg2 = (Dali::Radian *)jarg2;
51692   if (arg1) (arg1)->second = *arg2;
51693 }
51694
51695
51696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51697   void * jresult ;
51698   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51699   Dali::Radian *result = 0 ;
51700
51701   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51702   result = (Dali::Radian *)& ((arg1)->second);
51703   jresult = (void *)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51709   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51710
51711   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51712   {
51713     try {
51714       delete arg1;
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51722       };
51723     } catch (...) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51726       };
51727     }
51728   }
51729 }
51730
51731
51732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51733   unsigned int jresult ;
51734   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51735   bool result;
51736
51737   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51738   {
51739     try {
51740       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);
51741     } catch (std::out_of_range& e) {
51742       {
51743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51744       };
51745     } catch (std::exception& e) {
51746       {
51747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51748       };
51749     } catch (...) {
51750       {
51751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51752       };
51753     }
51754   }
51755   jresult = result;
51756   return jresult;
51757 }
51758
51759
51760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51761   unsigned long jresult ;
51762   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51763   std::size_t result;
51764
51765   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51766   {
51767     try {
51768       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);
51769     } catch (std::out_of_range& e) {
51770       {
51771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51772       };
51773     } catch (std::exception& e) {
51774       {
51775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51776       };
51777     } catch (...) {
51778       {
51779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51780       };
51781     }
51782   }
51783   jresult = (unsigned long)result;
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51789   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51790   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51791
51792   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51793   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51794   {
51795     try {
51796       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51797     } catch (std::out_of_range& e) {
51798       {
51799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51800       };
51801     } catch (std::exception& e) {
51802       {
51803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51804       };
51805     } catch (...) {
51806       {
51807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51808       };
51809     }
51810   }
51811 }
51812
51813
51814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51815   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51816   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51817
51818   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51819   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51820   {
51821     try {
51822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51823     } catch (std::out_of_range& e) {
51824       {
51825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51826       };
51827     } catch (std::exception& e) {
51828       {
51829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51834       };
51835     }
51836   }
51837 }
51838
51839
51840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51841   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51842   Dali::Actor arg2 ;
51843   Dali::PanGesture *arg3 = 0 ;
51844   Dali::Actor *argp2 ;
51845
51846   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51847   argp2 = (Dali::Actor *)jarg2;
51848   if (!argp2) {
51849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51850     return ;
51851   }
51852   arg2 = *argp2;
51853   arg3 = (Dali::PanGesture *)jarg3;
51854   if (!arg3) {
51855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51856     return ;
51857   }
51858   {
51859     try {
51860       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51861     } catch (std::out_of_range& e) {
51862       {
51863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51864       };
51865     } catch (std::exception& e) {
51866       {
51867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51868       };
51869     } catch (...) {
51870       {
51871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51872       };
51873     }
51874   }
51875 }
51876
51877
51878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51879   void * jresult ;
51880   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51881
51882   {
51883     try {
51884       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (void *)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51905   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51906
51907   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51908   {
51909     try {
51910       delete arg1;
51911     } catch (std::out_of_range& e) {
51912       {
51913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51914       };
51915     } catch (std::exception& e) {
51916       {
51917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51918       };
51919     } catch (...) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51922       };
51923     }
51924   }
51925 }
51926
51927
51928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51929   unsigned int jresult ;
51930   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51931   bool result;
51932
51933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51934   {
51935     try {
51936       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);
51937     } catch (std::out_of_range& e) {
51938       {
51939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51940       };
51941     } catch (std::exception& e) {
51942       {
51943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (...) {
51946       {
51947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51948       };
51949     }
51950   }
51951   jresult = result;
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51957   unsigned long jresult ;
51958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51959   std::size_t result;
51960
51961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51962   {
51963     try {
51964       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);
51965     } catch (std::out_of_range& e) {
51966       {
51967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51968       };
51969     } catch (std::exception& e) {
51970       {
51971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51972       };
51973     } catch (...) {
51974       {
51975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51976       };
51977     }
51978   }
51979   jresult = (unsigned long)result;
51980   return jresult;
51981 }
51982
51983
51984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51985   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51986   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51987
51988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51989   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51990   {
51991     try {
51992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007 }
52008
52009
52010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52011   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52012   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
52013
52014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52015   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
52016   {
52017     try {
52018       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52030       };
52031     }
52032   }
52033 }
52034
52035
52036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52037   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52038   Dali::Actor arg2 ;
52039   Dali::PinchGesture *arg3 = 0 ;
52040   Dali::Actor *argp2 ;
52041
52042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52043   argp2 = (Dali::Actor *)jarg2;
52044   if (!argp2) {
52045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52046     return ;
52047   }
52048   arg2 = *argp2;
52049   arg3 = (Dali::PinchGesture *)jarg3;
52050   if (!arg3) {
52051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
52052     return ;
52053   }
52054   {
52055     try {
52056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
52057     } catch (std::out_of_range& e) {
52058       {
52059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52060       };
52061     } catch (std::exception& e) {
52062       {
52063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (...) {
52066       {
52067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52068       };
52069     }
52070   }
52071 }
52072
52073
52074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
52075   void * jresult ;
52076   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
52077
52078   {
52079     try {
52080       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095   jresult = (void *)result;
52096   return jresult;
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52101   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52102
52103   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52104   {
52105     try {
52106       delete arg1;
52107     } catch (std::out_of_range& e) {
52108       {
52109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52110       };
52111     } catch (std::exception& e) {
52112       {
52113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52114       };
52115     } catch (...) {
52116       {
52117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52118       };
52119     }
52120   }
52121 }
52122
52123
52124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52125   unsigned int jresult ;
52126   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52127   bool result;
52128
52129   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52130   {
52131     try {
52132       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);
52133     } catch (std::out_of_range& e) {
52134       {
52135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52136       };
52137     } catch (std::exception& e) {
52138       {
52139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52140       };
52141     } catch (...) {
52142       {
52143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52144       };
52145     }
52146   }
52147   jresult = result;
52148   return jresult;
52149 }
52150
52151
52152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52153   unsigned long jresult ;
52154   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52155   std::size_t result;
52156
52157   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52158   {
52159     try {
52160       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);
52161     } catch (std::out_of_range& e) {
52162       {
52163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52164       };
52165     } catch (std::exception& e) {
52166       {
52167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52168       };
52169     } catch (...) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52172       };
52173     }
52174   }
52175   jresult = (unsigned long)result;
52176   return jresult;
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52181   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52182   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52183
52184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52185   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52186   {
52187     try {
52188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52200       };
52201     }
52202   }
52203 }
52204
52205
52206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52207   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52208   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52209
52210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52211   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52212   {
52213     try {
52214       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (...) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52226       };
52227     }
52228   }
52229 }
52230
52231
52232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52233   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52234   Dali::Actor arg2 ;
52235   Dali::TapGesture *arg3 = 0 ;
52236   Dali::Actor *argp2 ;
52237
52238   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52239   argp2 = (Dali::Actor *)jarg2;
52240   if (!argp2) {
52241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52242     return ;
52243   }
52244   arg2 = *argp2;
52245   arg3 = (Dali::TapGesture *)jarg3;
52246   if (!arg3) {
52247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52248     return ;
52249   }
52250   {
52251     try {
52252       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52264       };
52265     }
52266   }
52267 }
52268
52269
52270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52271   void * jresult ;
52272   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52273
52274   {
52275     try {
52276       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52277     } catch (std::out_of_range& e) {
52278       {
52279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52280       };
52281     } catch (std::exception& e) {
52282       {
52283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52284       };
52285     } catch (...) {
52286       {
52287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52288       };
52289     }
52290   }
52291   jresult = (void *)result;
52292   return jresult;
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52297   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52298
52299   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52300   {
52301     try {
52302       delete arg1;
52303     } catch (std::out_of_range& e) {
52304       {
52305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52306       };
52307     } catch (std::exception& e) {
52308       {
52309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52310       };
52311     } catch (...) {
52312       {
52313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52314       };
52315     }
52316   }
52317 }
52318
52319
52320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52321   unsigned int jresult ;
52322   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52323   bool result;
52324
52325   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52326   {
52327     try {
52328       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343   jresult = result;
52344   return jresult;
52345 }
52346
52347
52348 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52349   unsigned long jresult ;
52350   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52351   std::size_t result;
52352
52353   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52354   {
52355     try {
52356       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52357     } catch (std::out_of_range& e) {
52358       {
52359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52360       };
52361     } catch (std::exception& e) {
52362       {
52363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52364       };
52365     } catch (...) {
52366       {
52367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52368       };
52369     }
52370   }
52371   jresult = (unsigned long)result;
52372   return jresult;
52373 }
52374
52375
52376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52377   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52378   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52379
52380   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52381   arg2 = (void (*)(Dali::Animation &))jarg2;
52382   {
52383     try {
52384       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52392       };
52393     } catch (...) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52396       };
52397     }
52398   }
52399 }
52400
52401
52402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52403   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52404   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52405
52406   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52407   arg2 = (void (*)(Dali::Animation &))jarg2;
52408   {
52409     try {
52410       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52418       };
52419     } catch (...) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52422       };
52423     }
52424   }
52425 }
52426
52427
52428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52429   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52430   Dali::Animation *arg2 = 0 ;
52431
52432   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52433   arg2 = (Dali::Animation *)jarg2;
52434   if (!arg2) {
52435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52436     return ;
52437   }
52438   {
52439     try {
52440       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52441     } catch (std::out_of_range& e) {
52442       {
52443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52444       };
52445     } catch (std::exception& e) {
52446       {
52447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (...) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52452       };
52453     }
52454   }
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52459   void * jresult ;
52460   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52461
52462   {
52463     try {
52464       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52465     } catch (std::out_of_range& e) {
52466       {
52467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52468       };
52469     } catch (std::exception& e) {
52470       {
52471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52472       };
52473     } catch (...) {
52474       {
52475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52476       };
52477     }
52478   }
52479   jresult = (void *)result;
52480   return jresult;
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52485   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52486
52487   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52488   {
52489     try {
52490       delete arg1;
52491     } catch (std::out_of_range& e) {
52492       {
52493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52494       };
52495     } catch (std::exception& e) {
52496       {
52497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52498       };
52499     } catch (...) {
52500       {
52501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52502       };
52503     }
52504   }
52505 }
52506
52507
52508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52509   unsigned int jresult ;
52510   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52511   bool result;
52512
52513   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52514   {
52515     try {
52516       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52524       };
52525     } catch (...) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52528       };
52529     }
52530   }
52531   jresult = result;
52532   return jresult;
52533 }
52534
52535
52536 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52537   unsigned long jresult ;
52538   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52539   std::size_t result;
52540
52541   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52542   {
52543     try {
52544       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52545     } catch (std::out_of_range& e) {
52546       {
52547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52548       };
52549     } catch (std::exception& e) {
52550       {
52551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (...) {
52554       {
52555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52556       };
52557     }
52558   }
52559   jresult = (unsigned long)result;
52560   return jresult;
52561 }
52562
52563
52564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52565   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52566   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52567
52568   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52569   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52570   {
52571     try {
52572       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52573     } catch (std::out_of_range& e) {
52574       {
52575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52576       };
52577     } catch (std::exception& e) {
52578       {
52579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52584       };
52585     }
52586   }
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52591   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52592   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52593
52594   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52595   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52596   {
52597     try {
52598       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52599     } catch (std::out_of_range& e) {
52600       {
52601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52602       };
52603     } catch (std::exception& e) {
52604       {
52605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52606       };
52607     } catch (...) {
52608       {
52609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52610       };
52611     }
52612   }
52613 }
52614
52615
52616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52617   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52618   Dali::ResourceImage arg2 ;
52619   Dali::ResourceImage *argp2 ;
52620
52621   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52622   argp2 = (Dali::ResourceImage *)jarg2;
52623   if (!argp2) {
52624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52625     return ;
52626   }
52627   arg2 = *argp2;
52628   {
52629     try {
52630       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52631     } catch (std::out_of_range& e) {
52632       {
52633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52634       };
52635     } catch (std::exception& e) {
52636       {
52637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (...) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52642       };
52643     }
52644   }
52645 }
52646
52647
52648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52649   void * jresult ;
52650   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52651
52652   {
52653     try {
52654       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52655     } catch (std::out_of_range& e) {
52656       {
52657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52658       };
52659     } catch (std::exception& e) {
52660       {
52661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52662       };
52663     } catch (...) {
52664       {
52665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52666       };
52667     }
52668   }
52669   jresult = (void *)result;
52670   return jresult;
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52675   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52676
52677   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52678   {
52679     try {
52680       delete arg1;
52681     } catch (std::out_of_range& e) {
52682       {
52683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52684       };
52685     } catch (std::exception& e) {
52686       {
52687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52688       };
52689     } catch (...) {
52690       {
52691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52692       };
52693     }
52694   }
52695 }
52696
52697
52698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52699   unsigned int jresult ;
52700   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52701   bool result;
52702
52703   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52704   {
52705     try {
52706       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);
52707     } catch (std::out_of_range& e) {
52708       {
52709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52710       };
52711     } catch (std::exception& e) {
52712       {
52713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (...) {
52716       {
52717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52718       };
52719     }
52720   }
52721   jresult = result;
52722   return jresult;
52723 }
52724
52725
52726 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52727   unsigned long jresult ;
52728   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52729   std::size_t result;
52730
52731   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52732   {
52733     try {
52734       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);
52735     } catch (std::out_of_range& e) {
52736       {
52737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52738       };
52739     } catch (std::exception& e) {
52740       {
52741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (...) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52746       };
52747     }
52748   }
52749   jresult = (unsigned long)result;
52750   return jresult;
52751 }
52752
52753
52754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52755   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52756   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52757
52758   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52759   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52760   {
52761     try {
52762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52763     } catch (std::out_of_range& e) {
52764       {
52765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52766       };
52767     } catch (std::exception& e) {
52768       {
52769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52770       };
52771     } catch (...) {
52772       {
52773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52774       };
52775     }
52776   }
52777 }
52778
52779
52780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52781   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52782   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52783
52784   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52785   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52786   {
52787     try {
52788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52789     } catch (std::out_of_range& e) {
52790       {
52791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52792       };
52793     } catch (std::exception& e) {
52794       {
52795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52796       };
52797     } catch (...) {
52798       {
52799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52800       };
52801     }
52802   }
52803 }
52804
52805
52806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52807   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52808   Dali::Actor arg2 ;
52809   bool arg3 ;
52810   Dali::DevelActor::VisibilityChange::Type arg4 ;
52811   Dali::Actor *argp2 ;
52812
52813   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52814   argp2 = (Dali::Actor *)jarg2;
52815   if (!argp2) {
52816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52817     return ;
52818   }
52819   arg2 = *argp2;
52820   arg3 = jarg3 ? true : false;
52821   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52822   {
52823     try {
52824       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52825     } catch (std::out_of_range& e) {
52826       {
52827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52828       };
52829     } catch (std::exception& e) {
52830       {
52831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52832       };
52833     } catch (...) {
52834       {
52835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52836       };
52837     }
52838   }
52839 }
52840
52841
52842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52843   void * jresult ;
52844   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52845
52846   {
52847     try {
52848       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52849     } catch (std::out_of_range& e) {
52850       {
52851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52852       };
52853     } catch (std::exception& e) {
52854       {
52855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52856       };
52857     } catch (...) {
52858       {
52859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52860       };
52861     }
52862   }
52863   jresult = (void *)result;
52864   return jresult;
52865 }
52866
52867
52868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52869   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52870
52871   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52872   {
52873     try {
52874       delete arg1;
52875     } catch (std::out_of_range& e) {
52876       {
52877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52878       };
52879     } catch (std::exception& e) {
52880       {
52881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52882       };
52883     } catch (...) {
52884       {
52885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52886       };
52887     }
52888   }
52889 }
52890
52891
52892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52893   void * jresult ;
52894   Dali::Timer *result = 0 ;
52895
52896   {
52897     try {
52898       result = (Dali::Timer *)new Dali::Timer();
52899     } catch (std::out_of_range& e) {
52900       {
52901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (std::exception& e) {
52904       {
52905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52906       };
52907     } catch (...) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52910       };
52911     }
52912   }
52913   jresult = (void *)result;
52914   return jresult;
52915 }
52916
52917
52918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52919   void * jresult ;
52920   unsigned int arg1 ;
52921   Dali::Timer result;
52922
52923   arg1 = (unsigned int)jarg1;
52924   {
52925     try {
52926       result = Dali::Timer::New(arg1);
52927     } catch (std::out_of_range& e) {
52928       {
52929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52930       };
52931     } catch (std::exception& e) {
52932       {
52933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (...) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52938       };
52939     }
52940   }
52941   jresult = new Dali::Timer((const Dali::Timer &)result);
52942   return jresult;
52943 }
52944
52945
52946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52947   void * jresult ;
52948   Dali::Timer *arg1 = 0 ;
52949   Dali::Timer *result = 0 ;
52950
52951   arg1 = (Dali::Timer *)jarg1;
52952   if (!arg1) {
52953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52954     return 0;
52955   }
52956   {
52957     try {
52958       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52959     } catch (std::out_of_range& e) {
52960       {
52961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52962       };
52963     } catch (std::exception& e) {
52964       {
52965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52966       };
52967     } catch (...) {
52968       {
52969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52970       };
52971     }
52972   }
52973   jresult = (void *)result;
52974   return jresult;
52975 }
52976
52977
52978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52979   void * jresult ;
52980   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52981   Dali::Timer *arg2 = 0 ;
52982   Dali::Timer *result = 0 ;
52983
52984   arg1 = (Dali::Timer *)jarg1;
52985   arg2 = (Dali::Timer *)jarg2;
52986   if (!arg2) {
52987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52988     return 0;
52989   }
52990   {
52991     try {
52992       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53004       };
53005     }
53006   }
53007   jresult = (void *)result;
53008   return jresult;
53009 }
53010
53011
53012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
53013   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53014
53015   arg1 = (Dali::Timer *)jarg1;
53016   {
53017     try {
53018       delete arg1;
53019     } catch (std::out_of_range& e) {
53020       {
53021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53022       };
53023     } catch (std::exception& e) {
53024       {
53025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53026       };
53027     } catch (...) {
53028       {
53029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53030       };
53031     }
53032   }
53033 }
53034
53035
53036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
53037   void * jresult ;
53038   Dali::BaseHandle arg1 ;
53039   Dali::BaseHandle *argp1 ;
53040   Dali::Timer result;
53041
53042   argp1 = (Dali::BaseHandle *)jarg1;
53043   if (!argp1) {
53044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53045     return 0;
53046   }
53047   arg1 = *argp1;
53048   {
53049     try {
53050       result = Dali::Timer::DownCast(arg1);
53051     } catch (std::out_of_range& e) {
53052       {
53053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (std::exception& e) {
53056       {
53057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065   jresult = new Dali::Timer((const Dali::Timer &)result);
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
53071   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53072
53073   arg1 = (Dali::Timer *)jarg1;
53074   {
53075     try {
53076       (arg1)->Start();
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53088       };
53089     }
53090   }
53091 }
53092
53093
53094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53095   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53096
53097   arg1 = (Dali::Timer *)jarg1;
53098   {
53099     try {
53100       (arg1)->Stop();
53101     } catch (std::out_of_range& e) {
53102       {
53103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53104       };
53105     } catch (std::exception& e) {
53106       {
53107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (...) {
53110       {
53111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53112       };
53113     }
53114   }
53115 }
53116
53117
53118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53119   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53120   unsigned int arg2 ;
53121
53122   arg1 = (Dali::Timer *)jarg1;
53123   arg2 = (unsigned int)jarg2;
53124   {
53125     try {
53126       (arg1)->SetInterval(arg2);
53127     } catch (std::out_of_range& e) {
53128       {
53129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53130       };
53131     } catch (std::exception& e) {
53132       {
53133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53134       };
53135     } catch (...) {
53136       {
53137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53138       };
53139     }
53140   }
53141 }
53142
53143
53144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53145   unsigned int jresult ;
53146   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53147   unsigned int result;
53148
53149   arg1 = (Dali::Timer *)jarg1;
53150   {
53151     try {
53152       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167   jresult = result;
53168   return jresult;
53169 }
53170
53171
53172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53173   unsigned int jresult ;
53174   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53175   bool result;
53176
53177   arg1 = (Dali::Timer *)jarg1;
53178   {
53179     try {
53180       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53192       };
53193     }
53194   }
53195   jresult = result;
53196   return jresult;
53197 }
53198
53199
53200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53201   void * jresult ;
53202   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53203   Dali::Timer::TimerSignalType *result = 0 ;
53204
53205   arg1 = (Dali::Timer *)jarg1;
53206   {
53207     try {
53208       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53209     } catch (std::out_of_range& e) {
53210       {
53211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53212       };
53213     } catch (std::exception& e) {
53214       {
53215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53216       };
53217     } catch (...) {
53218       {
53219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53220       };
53221     }
53222   }
53223   jresult = (void *)result;
53224   return jresult;
53225 }
53226
53227
53228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53229   void * jresult ;
53230   Dali::DragAndDropDetector *result = 0 ;
53231
53232   {
53233     try {
53234       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53246       };
53247     }
53248   }
53249   jresult = (void *)result;
53250   return jresult;
53251 }
53252
53253
53254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53255   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53256
53257   arg1 = (Dali::DragAndDropDetector *)jarg1;
53258   {
53259     try {
53260       delete arg1;
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275 }
53276
53277
53278 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53279   char * jresult ;
53280   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53281   std::string *result = 0 ;
53282
53283   arg1 = (Dali::DragAndDropDetector *)jarg1;
53284   {
53285     try {
53286       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53287     } catch (std::out_of_range& e) {
53288       {
53289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (std::exception& e) {
53292       {
53293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53294       };
53295     } catch (...) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53298       };
53299     }
53300   }
53301   jresult = SWIG_csharp_string_callback(result->c_str());
53302   return jresult;
53303 }
53304
53305
53306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53307   void * jresult ;
53308   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53309   Dali::Vector2 result;
53310
53311   arg1 = (Dali::DragAndDropDetector *)jarg1;
53312   {
53313     try {
53314       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53315     } catch (std::out_of_range& e) {
53316       {
53317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53318       };
53319     } catch (std::exception& e) {
53320       {
53321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53322       };
53323     } catch (...) {
53324       {
53325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53326       };
53327     }
53328   }
53329   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53335   void * jresult ;
53336   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53337   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53338
53339   arg1 = (Dali::DragAndDropDetector *)jarg1;
53340   {
53341     try {
53342       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (...) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53354       };
53355     }
53356   }
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53363   void * jresult ;
53364   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53365   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53366
53367   arg1 = (Dali::DragAndDropDetector *)jarg1;
53368   {
53369     try {
53370       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53371     } catch (std::out_of_range& e) {
53372       {
53373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53374       };
53375     } catch (std::exception& e) {
53376       {
53377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53378       };
53379     } catch (...) {
53380       {
53381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53382       };
53383     }
53384   }
53385   jresult = (void *)result;
53386   return jresult;
53387 }
53388
53389
53390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53391   void * jresult ;
53392   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53393   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53394
53395   arg1 = (Dali::DragAndDropDetector *)jarg1;
53396   {
53397     try {
53398       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53399     } catch (std::out_of_range& e) {
53400       {
53401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53402       };
53403     } catch (std::exception& e) {
53404       {
53405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53410       };
53411     }
53412   }
53413   jresult = (void *)result;
53414   return jresult;
53415 }
53416
53417
53418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53419   void * jresult ;
53420   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53421   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53422
53423   arg1 = (Dali::DragAndDropDetector *)jarg1;
53424   {
53425     try {
53426       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53438       };
53439     }
53440   }
53441   jresult = (void *)result;
53442   return jresult;
53443 }
53444
53445
53446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53447   void * jresult ;
53448   Dali::ApplicationExtensions *result = 0 ;
53449
53450   {
53451     try {
53452       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53453     } catch (std::out_of_range& e) {
53454       {
53455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53456       };
53457     } catch (std::exception& e) {
53458       {
53459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53460       };
53461     } catch (...) {
53462       {
53463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53464       };
53465     }
53466   }
53467   jresult = (void *)result;
53468   return jresult;
53469 }
53470
53471
53472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53473   void * jresult ;
53474   Dali::Application *arg1 = (Dali::Application *) 0 ;
53475   Dali::ApplicationExtensions *result = 0 ;
53476
53477   arg1 = (Dali::Application *)jarg1;
53478   {
53479     try {
53480       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53481     } catch (std::out_of_range& e) {
53482       {
53483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53484       };
53485     } catch (std::exception& e) {
53486       {
53487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (...) {
53490       {
53491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53492       };
53493     }
53494   }
53495   jresult = (void *)result;
53496   return jresult;
53497 }
53498
53499
53500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53501   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53502
53503   arg1 = (Dali::ApplicationExtensions *)jarg1;
53504   {
53505     try {
53506       delete arg1;
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53514       };
53515     } catch (...) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53518       };
53519     }
53520   }
53521 }
53522
53523
53524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53525   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53526
53527   arg1 = (Dali::ApplicationExtensions *)jarg1;
53528   {
53529     try {
53530       (arg1)->Init();
53531     } catch (std::out_of_range& e) {
53532       {
53533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53534       };
53535     } catch (std::exception& e) {
53536       {
53537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53538       };
53539     } catch (...) {
53540       {
53541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53542       };
53543     }
53544   }
53545 }
53546
53547
53548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53549   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53550
53551   arg1 = (Dali::ApplicationExtensions *)jarg1;
53552   {
53553     try {
53554       (arg1)->Terminate();
53555     } catch (std::out_of_range& e) {
53556       {
53557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (std::exception& e) {
53560       {
53561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (...) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53566       };
53567     }
53568   }
53569 }
53570
53571
53572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53573   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53574
53575   arg1 = (Dali::ApplicationExtensions *)jarg1;
53576   {
53577     try {
53578       (arg1)->Pause();
53579     } catch (std::out_of_range& e) {
53580       {
53581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53582       };
53583     } catch (std::exception& e) {
53584       {
53585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53586       };
53587     } catch (...) {
53588       {
53589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53590       };
53591     }
53592   }
53593 }
53594
53595
53596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53597   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53598
53599   arg1 = (Dali::ApplicationExtensions *)jarg1;
53600   {
53601     try {
53602       (arg1)->Resume();
53603     } catch (std::out_of_range& e) {
53604       {
53605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53606       };
53607     } catch (std::exception& e) {
53608       {
53609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53610       };
53611     } catch (...) {
53612       {
53613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53614       };
53615     }
53616   }
53617 }
53618
53619
53620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53621   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53622
53623   arg1 = (Dali::ApplicationExtensions *)jarg1;
53624   {
53625     try {
53626       (arg1)->LanguageChange();
53627     } catch (std::out_of_range& e) {
53628       {
53629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53630       };
53631     } catch (std::exception& e) {
53632       {
53633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53634       };
53635     } catch (...) {
53636       {
53637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53638       };
53639     }
53640   }
53641 }
53642
53643
53644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53645   void * jresult ;
53646   Dali::PositionSize arg1 ;
53647   std::string *arg2 = 0 ;
53648   bool arg3 ;
53649   Dali::PositionSize *argp1 ;
53650   Dali::Window result;
53651
53652   argp1 = (Dali::PositionSize *)jarg1;
53653   if (!argp1) {
53654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53655     return 0;
53656   }
53657   arg1 = *argp1;
53658   if (!jarg2) {
53659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53660     return 0;
53661   }
53662   std::string arg2_str(jarg2);
53663   arg2 = &arg2_str;
53664   arg3 = jarg3 ? true : false;
53665   {
53666     try {
53667       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53668     } catch (std::out_of_range& e) {
53669       {
53670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53671       };
53672     } catch (std::exception& e) {
53673       {
53674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53675       };
53676     } catch (...) {
53677       {
53678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53679       };
53680     }
53681   }
53682   jresult = new Dali::Window((const Dali::Window &)result);
53683
53684   //argout typemap for const std::string&
53685
53686   return jresult;
53687 }
53688
53689
53690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53691   void * jresult ;
53692   Dali::PositionSize arg1 ;
53693   std::string *arg2 = 0 ;
53694   Dali::PositionSize *argp1 ;
53695   Dali::Window result;
53696
53697   argp1 = (Dali::PositionSize *)jarg1;
53698   if (!argp1) {
53699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53700     return 0;
53701   }
53702   arg1 = *argp1;
53703   if (!jarg2) {
53704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53705     return 0;
53706   }
53707   std::string arg2_str(jarg2);
53708   arg2 = &arg2_str;
53709   {
53710     try {
53711       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53712     } catch (std::out_of_range& e) {
53713       {
53714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (std::exception& e) {
53717       {
53718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (...) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53723       };
53724     }
53725   }
53726   jresult = new Dali::Window((const Dali::Window &)result);
53727
53728   //argout typemap for const std::string&
53729
53730   return jresult;
53731 }
53732
53733
53734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53735   void * jresult ;
53736   Dali::PositionSize arg1 ;
53737   std::string *arg2 = 0 ;
53738   std::string *arg3 = 0 ;
53739   bool arg4 ;
53740   Dali::PositionSize *argp1 ;
53741   Dali::Window result;
53742
53743   argp1 = (Dali::PositionSize *)jarg1;
53744   if (!argp1) {
53745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53746     return 0;
53747   }
53748   arg1 = *argp1;
53749   if (!jarg2) {
53750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53751     return 0;
53752   }
53753   std::string arg2_str(jarg2);
53754   arg2 = &arg2_str;
53755   if (!jarg3) {
53756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53757     return 0;
53758   }
53759   std::string arg3_str(jarg3);
53760   arg3 = &arg3_str;
53761   arg4 = jarg4 ? true : false;
53762   {
53763     try {
53764       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53765     } catch (std::out_of_range& e) {
53766       {
53767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (std::exception& e) {
53770       {
53771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53772       };
53773     } catch (...) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53776       };
53777     }
53778   }
53779   jresult = new Dali::Window((const Dali::Window &)result);
53780
53781   //argout typemap for const std::string&
53782
53783
53784   //argout typemap for const std::string&
53785
53786   return jresult;
53787 }
53788
53789
53790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53791   void * jresult ;
53792   Dali::PositionSize arg1 ;
53793   std::string *arg2 = 0 ;
53794   std::string *arg3 = 0 ;
53795   Dali::PositionSize *argp1 ;
53796   Dali::Window result;
53797
53798   argp1 = (Dali::PositionSize *)jarg1;
53799   if (!argp1) {
53800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53801     return 0;
53802   }
53803   arg1 = *argp1;
53804   if (!jarg2) {
53805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53806     return 0;
53807   }
53808   std::string arg2_str(jarg2);
53809   arg2 = &arg2_str;
53810   if (!jarg3) {
53811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53812     return 0;
53813   }
53814   std::string arg3_str(jarg3);
53815   arg3 = &arg3_str;
53816   {
53817     try {
53818       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (...) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53830       };
53831     }
53832   }
53833   jresult = new Dali::Window((const Dali::Window &)result);
53834
53835   //argout typemap for const std::string&
53836
53837
53838   //argout typemap for const std::string&
53839
53840   return jresult;
53841 }
53842
53843
53844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53845   void * jresult ;
53846   Dali::Window *result = 0 ;
53847
53848   {
53849     try {
53850       result = (Dali::Window *)new Dali::Window();
53851     } catch (std::out_of_range& e) {
53852       {
53853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53854       };
53855     } catch (std::exception& e) {
53856       {
53857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (...) {
53860       {
53861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53862       };
53863     }
53864   }
53865   jresult = (void *)result;
53866   return jresult;
53867 }
53868
53869
53870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53871   Dali::Window *arg1 = (Dali::Window *) 0 ;
53872
53873   arg1 = (Dali::Window *)jarg1;
53874   {
53875     try {
53876       delete arg1;
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_new_Window__SWIG_1(void * jarg1) {
53895   void * jresult ;
53896   Dali::Window *arg1 = 0 ;
53897   Dali::Window *result = 0 ;
53898
53899   arg1 = (Dali::Window *)jarg1;
53900   if (!arg1) {
53901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53902     return 0;
53903   }
53904   {
53905     try {
53906       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53907     } catch (std::out_of_range& e) {
53908       {
53909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53910       };
53911     } catch (std::exception& e) {
53912       {
53913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53918       };
53919     }
53920   }
53921   jresult = (void *)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53927   void * jresult ;
53928   Dali::Window *arg1 = (Dali::Window *) 0 ;
53929   Dali::Window *arg2 = 0 ;
53930   Dali::Window *result = 0 ;
53931
53932   arg1 = (Dali::Window *)jarg1;
53933   arg2 = (Dali::Window *)jarg2;
53934   if (!arg2) {
53935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53936     return 0;
53937   }
53938   {
53939     try {
53940       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53941     } catch (std::out_of_range& e) {
53942       {
53943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53944       };
53945     } catch (std::exception& e) {
53946       {
53947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53948       };
53949     } catch (...) {
53950       {
53951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53952       };
53953     }
53954   }
53955   jresult = (void *)result;
53956   return jresult;
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53961   Dali::Window *arg1 = (Dali::Window *) 0 ;
53962   Dali::Window::IndicatorVisibleMode arg2 ;
53963
53964   arg1 = (Dali::Window *)jarg1;
53965   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53966   {
53967     try {
53968       (arg1)->ShowIndicator(arg2);
53969     } catch (std::out_of_range& e) {
53970       {
53971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (std::exception& e) {
53974       {
53975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (...) {
53978       {
53979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53980       };
53981     }
53982   }
53983 }
53984
53985
53986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53987   Dali::Window *arg1 = (Dali::Window *) 0 ;
53988   Dali::Window::IndicatorBgOpacity arg2 ;
53989
53990   arg1 = (Dali::Window *)jarg1;
53991   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53992   {
53993     try {
53994       (arg1)->SetIndicatorBgOpacity(arg2);
53995     } catch (std::out_of_range& e) {
53996       {
53997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (std::exception& e) {
54000       {
54001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54002       };
54003     } catch (...) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54006       };
54007     }
54008   }
54009 }
54010
54011
54012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
54013   Dali::Window *arg1 = (Dali::Window *) 0 ;
54014   Dali::Window::WindowOrientation arg2 ;
54015
54016   arg1 = (Dali::Window *)jarg1;
54017   arg2 = (Dali::Window::WindowOrientation)jarg2;
54018   {
54019     try {
54020       (arg1)->RotateIndicator(arg2);
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (...) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54032       };
54033     }
54034   }
54035 }
54036
54037
54038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
54039   Dali::Window *arg1 = (Dali::Window *) 0 ;
54040   std::string arg2 ;
54041   std::string arg3 ;
54042
54043   arg1 = (Dali::Window *)jarg1;
54044   if (!jarg2) {
54045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54046     return ;
54047   }
54048   (&arg2)->assign(jarg2);
54049   if (!jarg3) {
54050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54051     return ;
54052   }
54053   (&arg3)->assign(jarg3);
54054   {
54055     try {
54056       (arg1)->SetClass(arg2,arg3);
54057     } catch (std::out_of_range& e) {
54058       {
54059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (std::exception& e) {
54062       {
54063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (...) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54068       };
54069     }
54070   }
54071 }
54072
54073
54074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
54075   Dali::Window *arg1 = (Dali::Window *) 0 ;
54076
54077   arg1 = (Dali::Window *)jarg1;
54078   {
54079     try {
54080       (arg1)->Raise();
54081     } catch (std::out_of_range& e) {
54082       {
54083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54084       };
54085     } catch (std::exception& e) {
54086       {
54087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54088       };
54089     } catch (...) {
54090       {
54091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54092       };
54093     }
54094   }
54095 }
54096
54097
54098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54099   Dali::Window *arg1 = (Dali::Window *) 0 ;
54100
54101   arg1 = (Dali::Window *)jarg1;
54102   {
54103     try {
54104       (arg1)->Lower();
54105     } catch (std::out_of_range& e) {
54106       {
54107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54108       };
54109     } catch (std::exception& e) {
54110       {
54111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54112       };
54113     } catch (...) {
54114       {
54115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54116       };
54117     }
54118   }
54119 }
54120
54121
54122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54123   Dali::Window *arg1 = (Dali::Window *) 0 ;
54124
54125   arg1 = (Dali::Window *)jarg1;
54126   {
54127     try {
54128       (arg1)->Activate();
54129     } catch (std::out_of_range& e) {
54130       {
54131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54132       };
54133     } catch (std::exception& e) {
54134       {
54135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54140       };
54141     }
54142   }
54143 }
54144
54145
54146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54147   Dali::Window *arg1 = (Dali::Window *) 0 ;
54148   Dali::Window::WindowOrientation arg2 ;
54149
54150   arg1 = (Dali::Window *)jarg1;
54151   arg2 = (Dali::Window::WindowOrientation)jarg2;
54152   {
54153     try {
54154       (arg1)->AddAvailableOrientation(arg2);
54155     } catch (std::out_of_range& e) {
54156       {
54157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (std::exception& e) {
54160       {
54161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54162       };
54163     } catch (...) {
54164       {
54165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54166       };
54167     }
54168   }
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54173   Dali::Window *arg1 = (Dali::Window *) 0 ;
54174   Dali::Window::WindowOrientation arg2 ;
54175
54176   arg1 = (Dali::Window *)jarg1;
54177   arg2 = (Dali::Window::WindowOrientation)jarg2;
54178   {
54179     try {
54180       (arg1)->RemoveAvailableOrientation(arg2);
54181     } catch (std::out_of_range& e) {
54182       {
54183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (std::exception& e) {
54186       {
54187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (...) {
54190       {
54191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54192       };
54193     }
54194   }
54195 }
54196
54197
54198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54199   Dali::Window *arg1 = (Dali::Window *) 0 ;
54200   Dali::Window::WindowOrientation arg2 ;
54201
54202   arg1 = (Dali::Window *)jarg1;
54203   arg2 = (Dali::Window::WindowOrientation)jarg2;
54204   {
54205     try {
54206       (arg1)->SetPreferredOrientation(arg2);
54207     } catch (std::out_of_range& e) {
54208       {
54209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54210       };
54211     } catch (std::exception& e) {
54212       {
54213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54214       };
54215     } catch (...) {
54216       {
54217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54218       };
54219     }
54220   }
54221 }
54222
54223
54224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54225   int jresult ;
54226   Dali::Window *arg1 = (Dali::Window *) 0 ;
54227   Dali::Window::WindowOrientation result;
54228
54229   arg1 = (Dali::Window *)jarg1;
54230   {
54231     try {
54232       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54233     } catch (std::out_of_range& e) {
54234       {
54235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54236       };
54237     } catch (std::exception& e) {
54238       {
54239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54240       };
54241     } catch (...) {
54242       {
54243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54244       };
54245     }
54246   }
54247   jresult = (int)result;
54248   return jresult;
54249 }
54250
54251
54252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54253   void * jresult ;
54254   Dali::Window *arg1 = (Dali::Window *) 0 ;
54255   Dali::DragAndDropDetector result;
54256
54257   arg1 = (Dali::Window *)jarg1;
54258   {
54259     try {
54260       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54261     } catch (std::out_of_range& e) {
54262       {
54263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54264       };
54265     } catch (std::exception& e) {
54266       {
54267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54268       };
54269     } catch (...) {
54270       {
54271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54272       };
54273     }
54274   }
54275   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54276   return jresult;
54277 }
54278
54279
54280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54281   void * jresult ;
54282   Dali::Window *arg1 = (Dali::Window *) 0 ;
54283   Dali::Any result;
54284
54285   arg1 = (Dali::Window *)jarg1;
54286   {
54287     try {
54288       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54289     } catch (std::out_of_range& e) {
54290       {
54291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54292       };
54293     } catch (std::exception& e) {
54294       {
54295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54300       };
54301     }
54302   }
54303   jresult = new Dali::Any((const Dali::Any &)result);
54304   return jresult;
54305 }
54306
54307
54308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54309   void * jresult ;
54310   Dali::Window arg1 ;
54311   Dali::Window *argp1 ;
54312   Dali::DevelWindow::FocusSignalType *result = 0 ;
54313
54314   argp1 = (Dali::Window *)jarg1;
54315   if (!argp1) {
54316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54317     return 0;
54318   }
54319   arg1 = *argp1;
54320   {
54321     try {
54322       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54323     } catch (std::out_of_range& e) {
54324       {
54325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54326       };
54327     } catch (std::exception& e) {
54328       {
54329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54330       };
54331     } catch (...) {
54332       {
54333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54334       };
54335     }
54336   }
54337   jresult = (void *)result;
54338   return jresult;
54339 }
54340
54341
54342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54343   Dali::Window arg1 ;
54344   bool arg2 ;
54345   Dali::Window *argp1 ;
54346
54347   argp1 = (Dali::Window *)jarg1;
54348   if (!argp1) {
54349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54350     return ;
54351   }
54352   arg1 = *argp1;
54353   arg2 = jarg2 ? true : false;
54354   {
54355     try {
54356       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54357     } catch (std::out_of_range& e) {
54358       {
54359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54360       };
54361     } catch (std::exception& e) {
54362       {
54363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54364       };
54365     } catch (...) {
54366       {
54367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54368       };
54369     }
54370   }
54371 }
54372
54373
54374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54375   unsigned int jresult ;
54376   Dali::Window arg1 ;
54377   Dali::Window *argp1 ;
54378   bool result;
54379
54380   argp1 = (Dali::Window *)jarg1;
54381   if (!argp1) {
54382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54383     return 0;
54384   }
54385   arg1 = *argp1;
54386   {
54387     try {
54388       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54389     } catch (std::out_of_range& e) {
54390       {
54391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54392       };
54393     } catch (std::exception& e) {
54394       {
54395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54396       };
54397     } catch (...) {
54398       {
54399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54400       };
54401     }
54402   }
54403   jresult = result;
54404   return jresult;
54405 }
54406
54407
54408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54409   Dali::Window arg1 ;
54410   Dali::Window *argp1 ;
54411
54412   argp1 = (Dali::Window *)jarg1;
54413   if (!argp1) {
54414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54415     return ;
54416   }
54417   arg1 = *argp1;
54418   {
54419     try {
54420       Dali::DevelWindow::Show(arg1);
54421     } catch (std::out_of_range& e) {
54422       {
54423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54424       };
54425     } catch (std::exception& e) {
54426       {
54427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54428       };
54429     } catch (...) {
54430       {
54431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54432       };
54433     }
54434   }
54435 }
54436
54437
54438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54439   Dali::Window arg1 ;
54440   Dali::Window *argp1 ;
54441
54442   argp1 = (Dali::Window *)jarg1;
54443   if (!argp1) {
54444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54445     return ;
54446   }
54447   arg1 = *argp1;
54448   {
54449     try {
54450       Dali::DevelWindow::Hide(arg1);
54451     } catch (std::out_of_range& e) {
54452       {
54453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54454       };
54455     } catch (std::exception& e) {
54456       {
54457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (...) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54462       };
54463     }
54464   }
54465 }
54466
54467
54468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54469   unsigned int jresult ;
54470   Dali::Window arg1 ;
54471   Dali::Window *argp1 ;
54472   bool result;
54473
54474   argp1 = (Dali::Window *)jarg1;
54475   if (!argp1) {
54476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54477     return 0;
54478   }
54479   arg1 = *argp1;
54480   {
54481     try {
54482       result = (bool)Dali::DevelWindow::IsVisible(arg1);
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 = result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54503   unsigned int jresult ;
54504   Dali::Window arg1 ;
54505   Dali::Window *argp1 ;
54506   unsigned int result;
54507
54508   argp1 = (Dali::Window *)jarg1;
54509   if (!argp1) {
54510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54511     return 0;
54512   }
54513   arg1 = *argp1;
54514   {
54515     try {
54516       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54517     } catch (std::out_of_range& e) {
54518       {
54519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54520       };
54521     } catch (std::exception& e) {
54522       {
54523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54528       };
54529     }
54530   }
54531   jresult = result;
54532   return jresult;
54533 }
54534
54535
54536 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54537   char * jresult ;
54538   Dali::Window arg1 ;
54539   unsigned int arg2 ;
54540   Dali::Window *argp1 ;
54541   std::string result;
54542
54543   argp1 = (Dali::Window *)jarg1;
54544   if (!argp1) {
54545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54546     return 0;
54547   }
54548   arg1 = *argp1;
54549   arg2 = (unsigned int)jarg2;
54550   {
54551     try {
54552       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54553     } catch (std::out_of_range& e) {
54554       {
54555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54556       };
54557     } catch (std::exception& e) {
54558       {
54559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54560       };
54561     } catch (...) {
54562       {
54563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54564       };
54565     }
54566   }
54567   jresult = SWIG_csharp_string_callback((&result)->c_str());
54568   return jresult;
54569 }
54570
54571
54572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54573   unsigned int jresult ;
54574   Dali::Window arg1 ;
54575   std::string *arg2 = 0 ;
54576   std::string *arg3 = 0 ;
54577   Dali::Window *argp1 ;
54578   unsigned int result;
54579
54580   argp1 = (Dali::Window *)jarg1;
54581   if (!argp1) {
54582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54583     return 0;
54584   }
54585   arg1 = *argp1;
54586   if (!jarg2) {
54587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54588     return 0;
54589   }
54590   std::string arg2_str(jarg2);
54591   arg2 = &arg2_str;
54592   if (!jarg3) {
54593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54594     return 0;
54595   }
54596   std::string arg3_str(jarg3);
54597   arg3 = &arg3_str;
54598   {
54599     try {
54600       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54601     } catch (std::out_of_range& e) {
54602       {
54603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54604       };
54605     } catch (std::exception& e) {
54606       {
54607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54608       };
54609     } catch (...) {
54610       {
54611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54612       };
54613     }
54614   }
54615   jresult = result;
54616
54617   //argout typemap for const std::string&
54618
54619
54620   //argout typemap for const std::string&
54621
54622   return jresult;
54623 }
54624
54625
54626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54627   unsigned int jresult ;
54628   Dali::Window arg1 ;
54629   unsigned int arg2 ;
54630   Dali::Window *argp1 ;
54631   bool result;
54632
54633   argp1 = (Dali::Window *)jarg1;
54634   if (!argp1) {
54635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54636     return 0;
54637   }
54638   arg1 = *argp1;
54639   arg2 = (unsigned int)jarg2;
54640   {
54641     try {
54642       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54643     } catch (std::out_of_range& e) {
54644       {
54645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54646       };
54647     } catch (std::exception& e) {
54648       {
54649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54650       };
54651     } catch (...) {
54652       {
54653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54654       };
54655     }
54656   }
54657   jresult = result;
54658   return jresult;
54659 }
54660
54661
54662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54663   unsigned int jresult ;
54664   Dali::Window arg1 ;
54665   unsigned int arg2 ;
54666   std::string *arg3 = 0 ;
54667   Dali::Window *argp1 ;
54668   bool result;
54669
54670   argp1 = (Dali::Window *)jarg1;
54671   if (!argp1) {
54672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54673     return 0;
54674   }
54675   arg1 = *argp1;
54676   arg2 = (unsigned int)jarg2;
54677   if (!jarg3) {
54678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54679     return 0;
54680   }
54681   std::string arg3_str(jarg3);
54682   arg3 = &arg3_str;
54683   {
54684     try {
54685       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (...) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54697       };
54698     }
54699   }
54700   jresult = result;
54701
54702   //argout typemap for const std::string&
54703
54704   return jresult;
54705 }
54706
54707
54708 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54709   char * jresult ;
54710   Dali::Window arg1 ;
54711   unsigned int arg2 ;
54712   Dali::Window *argp1 ;
54713   std::string result;
54714
54715   argp1 = (Dali::Window *)jarg1;
54716   if (!argp1) {
54717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54718     return 0;
54719   }
54720   arg1 = *argp1;
54721   arg2 = (unsigned int)jarg2;
54722   {
54723     try {
54724       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54725     } catch (std::out_of_range& e) {
54726       {
54727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54728       };
54729     } catch (std::exception& e) {
54730       {
54731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (...) {
54734       {
54735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54736       };
54737     }
54738   }
54739   jresult = SWIG_csharp_string_callback((&result)->c_str());
54740   return jresult;
54741 }
54742
54743
54744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54745   unsigned int jresult ;
54746   Dali::Window arg1 ;
54747   std::string *arg2 = 0 ;
54748   Dali::Window *argp1 ;
54749   unsigned int result;
54750
54751   argp1 = (Dali::Window *)jarg1;
54752   if (!argp1) {
54753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54754     return 0;
54755   }
54756   arg1 = *argp1;
54757   if (!jarg2) {
54758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54759     return 0;
54760   }
54761   std::string arg2_str(jarg2);
54762   arg2 = &arg2_str;
54763   {
54764     try {
54765       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54766     } catch (std::out_of_range& e) {
54767       {
54768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54769       };
54770     } catch (std::exception& e) {
54771       {
54772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54773       };
54774     } catch (...) {
54775       {
54776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54777       };
54778     }
54779   }
54780   jresult = result;
54781
54782   //argout typemap for const std::string&
54783
54784   return jresult;
54785 }
54786
54787
54788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54789   Dali::Window arg1 ;
54790   Dali::Rect< int > *arg2 = 0 ;
54791   Dali::Window *argp1 ;
54792
54793   argp1 = (Dali::Window *)jarg1;
54794   if (!argp1) {
54795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54796     return ;
54797   }
54798   arg1 = *argp1;
54799   arg2 = (Dali::Rect< int > *)jarg2;
54800   if (!arg2) {
54801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54802     return ;
54803   }
54804   {
54805     try {
54806       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54807     } catch (std::out_of_range& e) {
54808       {
54809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54810       };
54811     } catch (std::exception& e) {
54812       {
54813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54814       };
54815     } catch (...) {
54816       {
54817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54818       };
54819     }
54820   }
54821 }
54822
54823
54824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54825   Dali::Window arg1 ;
54826   Dali::DevelWindow::Type arg2 ;
54827   Dali::Window *argp1 ;
54828
54829   argp1 = (Dali::Window *)jarg1;
54830   if (!argp1) {
54831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54832     return ;
54833   }
54834   arg1 = *argp1;
54835   arg2 = (Dali::DevelWindow::Type)jarg2;
54836   {
54837     try {
54838       Dali::DevelWindow::SetType(arg1,arg2);
54839     } catch (std::out_of_range& e) {
54840       {
54841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54842       };
54843     } catch (std::exception& e) {
54844       {
54845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54846       };
54847     } catch (...) {
54848       {
54849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54850       };
54851     }
54852   }
54853 }
54854
54855
54856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54857   int jresult ;
54858   Dali::Window arg1 ;
54859   Dali::Window *argp1 ;
54860   Dali::DevelWindow::Type result;
54861
54862   argp1 = (Dali::Window *)jarg1;
54863   if (!argp1) {
54864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54865     return 0;
54866   }
54867   arg1 = *argp1;
54868   {
54869     try {
54870       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54871     } catch (std::out_of_range& e) {
54872       {
54873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54874       };
54875     } catch (std::exception& e) {
54876       {
54877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54878       };
54879     } catch (...) {
54880       {
54881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54882       };
54883     }
54884   }
54885   jresult = (int)result;
54886   return jresult;
54887 }
54888
54889
54890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54891   unsigned int jresult ;
54892   Dali::Window arg1 ;
54893   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54894   Dali::Window *argp1 ;
54895   bool result;
54896
54897   argp1 = (Dali::Window *)jarg1;
54898   if (!argp1) {
54899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54900     return 0;
54901   }
54902   arg1 = *argp1;
54903   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54904   {
54905     try {
54906       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54907     } catch (std::out_of_range& e) {
54908       {
54909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54910       };
54911     } catch (std::exception& e) {
54912       {
54913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54914       };
54915     } catch (...) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54918       };
54919     }
54920   }
54921   jresult = result;
54922   return jresult;
54923 }
54924
54925
54926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54927   int jresult ;
54928   Dali::Window arg1 ;
54929   Dali::Window *argp1 ;
54930   Dali::DevelWindow::NotificationLevel::Type result;
54931
54932   argp1 = (Dali::Window *)jarg1;
54933   if (!argp1) {
54934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54935     return 0;
54936   }
54937   arg1 = *argp1;
54938   {
54939     try {
54940       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54941     } catch (std::out_of_range& e) {
54942       {
54943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54944       };
54945     } catch (std::exception& e) {
54946       {
54947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54952       };
54953     }
54954   }
54955   jresult = (int)result;
54956   return jresult;
54957 }
54958
54959
54960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54961   Dali::Window arg1 ;
54962   bool arg2 ;
54963   Dali::Window *argp1 ;
54964
54965   argp1 = (Dali::Window *)jarg1;
54966   if (!argp1) {
54967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54968     return ;
54969   }
54970   arg1 = *argp1;
54971   arg2 = jarg2 ? true : false;
54972   {
54973     try {
54974       Dali::DevelWindow::SetOpaqueState(arg1,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 unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
54993   unsigned int jresult ;
54994   Dali::Window arg1 ;
54995   Dali::Window *argp1 ;
54996   bool result;
54997
54998   argp1 = (Dali::Window *)jarg1;
54999   if (!argp1) {
55000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55001     return 0;
55002   }
55003   arg1 = *argp1;
55004   {
55005     try {
55006       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
55007     } catch (std::out_of_range& e) {
55008       {
55009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55010       };
55011     } catch (std::exception& e) {
55012       {
55013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55014       };
55015     } catch (...) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55018       };
55019     }
55020   }
55021   jresult = result;
55022   return jresult;
55023 }
55024
55025
55026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
55027   unsigned int jresult ;
55028   Dali::Window arg1 ;
55029   Dali::DevelWindow::ScreenMode::Type arg2 ;
55030   Dali::Window *argp1 ;
55031   bool result;
55032
55033   argp1 = (Dali::Window *)jarg1;
55034   if (!argp1) {
55035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55036     return 0;
55037   }
55038   arg1 = *argp1;
55039   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
55040   {
55041     try {
55042       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55050       };
55051     } catch (...) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55054       };
55055     }
55056   }
55057   jresult = result;
55058   return jresult;
55059 }
55060
55061
55062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
55063   int jresult ;
55064   Dali::Window arg1 ;
55065   Dali::Window *argp1 ;
55066   Dali::DevelWindow::ScreenMode::Type result;
55067
55068   argp1 = (Dali::Window *)jarg1;
55069   if (!argp1) {
55070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55071     return 0;
55072   }
55073   arg1 = *argp1;
55074   {
55075     try {
55076       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55088       };
55089     }
55090   }
55091   jresult = (int)result;
55092   return jresult;
55093 }
55094
55095
55096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55097   unsigned int jresult ;
55098   Dali::Window arg1 ;
55099   int arg2 ;
55100   Dali::Window *argp1 ;
55101   bool result;
55102
55103   argp1 = (Dali::Window *)jarg1;
55104   if (!argp1) {
55105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55106     return 0;
55107   }
55108   arg1 = *argp1;
55109   arg2 = (int)jarg2;
55110   {
55111     try {
55112       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55113     } catch (std::out_of_range& e) {
55114       {
55115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55116       };
55117     } catch (std::exception& e) {
55118       {
55119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55120       };
55121     } catch (...) {
55122       {
55123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55124       };
55125     }
55126   }
55127   jresult = result;
55128   return jresult;
55129 }
55130
55131
55132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55133   int jresult ;
55134   Dali::Window arg1 ;
55135   Dali::Window *argp1 ;
55136   int result;
55137
55138   argp1 = (Dali::Window *)jarg1;
55139   if (!argp1) {
55140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55141     return 0;
55142   }
55143   arg1 = *argp1;
55144   {
55145     try {
55146       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55147     } catch (std::out_of_range& e) {
55148       {
55149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (std::exception& e) {
55152       {
55153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55154       };
55155     } catch (...) {
55156       {
55157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55158       };
55159     }
55160   }
55161   jresult = result;
55162   return jresult;
55163 }
55164
55165
55166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55167   void * jresult ;
55168   Dali::Application result;
55169
55170   {
55171     try {
55172       result = Dali::Application::New();
55173     } catch (std::out_of_range& e) {
55174       {
55175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55176       };
55177     } catch (std::exception& e) {
55178       {
55179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55180       };
55181     } catch (...) {
55182       {
55183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55184       };
55185     }
55186   }
55187   jresult = new Dali::Application((const Dali::Application &)result);
55188   return jresult;
55189 }
55190
55191
55192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55193   void * jresult ;
55194   int *arg1 = (int *) 0 ;
55195   char ***arg2 ;
55196   Dali::Application result;
55197
55198   {
55199     // Todo generate argv data from the C# args
55200     char **array;         // two dimensional array
55201     int numStrings = 1;     // number of strings
55202     int stringLength = 30;      // max string length.
55203     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55204     argV = array;
55205
55206     // allocate the string data
55207     for( int i=0; i < numStrings; i++)
55208     {
55209       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55210     }
55211     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55212
55213     strcpy( array[0], "dali-csharp-app");
55214
55215     arg1 = &argC;
55216     arg2 = &argV;
55217   }
55218   {
55219     try {
55220       result = Dali::Application::New(arg1,arg2);
55221     } catch (std::out_of_range& e) {
55222       {
55223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55224       };
55225     } catch (std::exception& e) {
55226       {
55227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55228       };
55229     } catch (...) {
55230       {
55231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55232       };
55233     }
55234   }
55235   jresult = new Dali::Application((const Dali::Application &)result);
55236   return jresult;
55237 }
55238
55239
55240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55241   void * jresult ;
55242   int *arg1 = (int *) 0 ;
55243   char ***arg2 ;
55244   std::string *arg3 = 0 ;
55245   Dali::Application result;
55246
55247   {
55248     // Todo generate argv data from the C# args
55249     char **array;         // two dimensional array
55250     int numStrings = 1;     // number of strings
55251     int stringLength = 30;      // max string length.
55252     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55253     argV = array;
55254
55255     // allocate the string data
55256     for( int i=0; i < numStrings; i++)
55257     {
55258       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55259     }
55260     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55261
55262     strcpy( array[0], "dali-csharp-app");
55263
55264     arg1 = &argC;
55265     arg2 = &argV;
55266   }
55267   if (!jarg3) {
55268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55269     return 0;
55270   }
55271   std::string arg3_str(jarg3);
55272   arg3 = &arg3_str;
55273   {
55274     try {
55275       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55276     } catch (std::out_of_range& e) {
55277       {
55278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55279       };
55280     } catch (std::exception& e) {
55281       {
55282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55287       };
55288     }
55289   }
55290   jresult = new Dali::Application((const Dali::Application &)result);
55291
55292   //argout typemap for const std::string&
55293
55294   return jresult;
55295 }
55296
55297
55298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55299   void * jresult ;
55300   int *arg1 = (int *) 0 ;
55301   char ***arg2 ;
55302   std::string *arg3 = 0 ;
55303   Dali::Application::WINDOW_MODE arg4 ;
55304   Dali::Application result;
55305
55306   {
55307     // Todo generate argv data from the C# args
55308     char **array;         // two dimensional array
55309     int numStrings = 1;     // number of strings
55310     int stringLength = 30;      // max string length.
55311     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55312     argV = array;
55313
55314     // allocate the string data
55315     for( int i=0; i < numStrings; i++)
55316     {
55317       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55318     }
55319     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55320
55321     strcpy( array[0], "dali-csharp-app");
55322
55323     arg1 = &argC;
55324     arg2 = &argV;
55325   }
55326   if (!jarg3) {
55327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55328     return 0;
55329   }
55330   std::string arg3_str(jarg3);
55331   arg3 = &arg3_str;
55332   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55333   {
55334     try {
55335       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55336     } catch (std::out_of_range& e) {
55337       {
55338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55339       };
55340     } catch (std::exception& e) {
55341       {
55342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55347       };
55348     }
55349   }
55350   jresult = new Dali::Application((const Dali::Application &)result);
55351
55352   //argout typemap for const std::string&
55353
55354   return jresult;
55355 }
55356
55357
55358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55359   void * jresult ;
55360   Dali::Application *result = 0 ;
55361
55362   {
55363     try {
55364       result = (Dali::Application *)new Dali::Application();
55365     } catch (std::out_of_range& e) {
55366       {
55367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55368       };
55369     } catch (std::exception& e) {
55370       {
55371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55372       };
55373     } catch (...) {
55374       {
55375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55376       };
55377     }
55378   }
55379   jresult = (void *)result;
55380   return jresult;
55381 }
55382
55383
55384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55385   void * jresult ;
55386   Dali::Application *arg1 = 0 ;
55387   Dali::Application *result = 0 ;
55388
55389   arg1 = (Dali::Application *)jarg1;
55390   if (!arg1) {
55391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55392     return 0;
55393   }
55394   {
55395     try {
55396       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55397     } catch (std::out_of_range& e) {
55398       {
55399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55400       };
55401     } catch (std::exception& e) {
55402       {
55403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55404       };
55405     } catch (...) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55408       };
55409     }
55410   }
55411   jresult = (void *)result;
55412   return jresult;
55413 }
55414
55415
55416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55417   void * jresult ;
55418   Dali::Application *arg1 = (Dali::Application *) 0 ;
55419   Dali::Application *arg2 = 0 ;
55420   Dali::Application *result = 0 ;
55421
55422   arg1 = (Dali::Application *)jarg1;
55423   arg2 = (Dali::Application *)jarg2;
55424   if (!arg2) {
55425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55426     return 0;
55427   }
55428   {
55429     try {
55430       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55431     } catch (std::out_of_range& e) {
55432       {
55433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55434       };
55435     } catch (std::exception& e) {
55436       {
55437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (...) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55442       };
55443     }
55444   }
55445   jresult = (void *)result;
55446   return jresult;
55447 }
55448
55449
55450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55451   Dali::Application *arg1 = (Dali::Application *) 0 ;
55452
55453   arg1 = (Dali::Application *)jarg1;
55454   {
55455     try {
55456       delete arg1;
55457     } catch (std::out_of_range& e) {
55458       {
55459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55460       };
55461     } catch (std::exception& e) {
55462       {
55463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55464       };
55465     } catch (...) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55468       };
55469     }
55470   }
55471 }
55472
55473
55474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55475   Dali::Application *arg1 = (Dali::Application *) 0 ;
55476
55477   arg1 = (Dali::Application *)jarg1;
55478   {
55479     try {
55480       (arg1)->MainLoop();
55481     } catch (std::out_of_range& e) {
55482       {
55483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55484       };
55485     } catch (std::exception& e) {
55486       {
55487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55488       };
55489     } catch (...) {
55490       {
55491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55492       };
55493     }
55494   }
55495 }
55496
55497
55498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55499   Dali::Application *arg1 = (Dali::Application *) 0 ;
55500   Configuration::ContextLoss arg2 ;
55501   Configuration::ContextLoss *argp2 ;
55502
55503   arg1 = (Dali::Application *)jarg1;
55504   argp2 = (Configuration::ContextLoss *)jarg2;
55505   if (!argp2) {
55506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55507     return ;
55508   }
55509   arg2 = *argp2;
55510   {
55511     try {
55512       (arg1)->MainLoop(arg2);
55513     } catch (std::out_of_range& e) {
55514       {
55515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55516       };
55517     } catch (std::exception& e) {
55518       {
55519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55524       };
55525     }
55526   }
55527 }
55528
55529
55530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55531   Dali::Application *arg1 = (Dali::Application *) 0 ;
55532
55533   arg1 = (Dali::Application *)jarg1;
55534   {
55535     try {
55536       (arg1)->Lower();
55537     } catch (std::out_of_range& e) {
55538       {
55539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55540       };
55541     } catch (std::exception& e) {
55542       {
55543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55544       };
55545     } catch (...) {
55546       {
55547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55548       };
55549     }
55550   }
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55555   Dali::Application *arg1 = (Dali::Application *) 0 ;
55556
55557   arg1 = (Dali::Application *)jarg1;
55558   {
55559     try {
55560       (arg1)->Quit();
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (...) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55572       };
55573     }
55574   }
55575 }
55576
55577
55578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55579   unsigned int jresult ;
55580   Dali::Application *arg1 = (Dali::Application *) 0 ;
55581   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55582   bool result;
55583
55584   arg1 = (Dali::Application *)jarg1;
55585   arg2 = (Dali::CallbackBase *)jarg2;
55586   {
55587     try {
55588       result = (bool)(arg1)->AddIdle(arg2);
55589     } catch (std::out_of_range& e) {
55590       {
55591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (std::exception& e) {
55594       {
55595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55596       };
55597     } catch (...) {
55598       {
55599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55600       };
55601     }
55602   }
55603   jresult = result;
55604   return jresult;
55605 }
55606
55607
55608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55609   void * jresult ;
55610   Dali::Application *arg1 = (Dali::Application *) 0 ;
55611   Dali::Window result;
55612
55613   arg1 = (Dali::Application *)jarg1;
55614   {
55615     try {
55616       result = (arg1)->GetWindow();
55617     } catch (std::out_of_range& e) {
55618       {
55619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55620       };
55621     } catch (std::exception& e) {
55622       {
55623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55624       };
55625     } catch (...) {
55626       {
55627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55628       };
55629     }
55630   }
55631   jresult = new Dali::Window((const Dali::Window &)result);
55632   return jresult;
55633 }
55634
55635
55636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55637   Dali::Application *arg1 = (Dali::Application *) 0 ;
55638   Dali::PositionSize arg2 ;
55639   std::string *arg3 = 0 ;
55640   Dali::PositionSize *argp2 ;
55641
55642   arg1 = (Dali::Application *)jarg1;
55643   argp2 = (Dali::PositionSize *)jarg2;
55644   if (!argp2) {
55645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55646     return ;
55647   }
55648   arg2 = *argp2;
55649   if (!jarg3) {
55650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55651     return ;
55652   }
55653   std::string arg3_str(jarg3);
55654   arg3 = &arg3_str;
55655   {
55656     try {
55657       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (...) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55669       };
55670     }
55671   }
55672
55673   //argout typemap for const std::string&
55674
55675 }
55676
55677
55678 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55679   char * jresult ;
55680   std::string result;
55681
55682   {
55683     try {
55684       result = Dali::Application::GetResourcePath();
55685     } catch (std::out_of_range& e) {
55686       {
55687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55688       };
55689     } catch (std::exception& e) {
55690       {
55691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55696       };
55697     }
55698   }
55699   jresult = SWIG_csharp_string_callback((&result)->c_str());
55700   return jresult;
55701 }
55702
55703
55704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55705   Dali::Application *arg1 = (Dali::Application *) 0 ;
55706   Dali::ViewMode arg2 ;
55707
55708   arg1 = (Dali::Application *)jarg1;
55709   arg2 = (Dali::ViewMode)jarg2;
55710   {
55711     try {
55712       (arg1)->SetViewMode(arg2);
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (...) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55724       };
55725     }
55726   }
55727 }
55728
55729
55730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55731   int jresult ;
55732   Dali::Application *arg1 = (Dali::Application *) 0 ;
55733   Dali::ViewMode result;
55734
55735   arg1 = (Dali::Application *)jarg1;
55736   {
55737     try {
55738       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55739     } catch (std::out_of_range& e) {
55740       {
55741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (std::exception& e) {
55744       {
55745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (...) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55750       };
55751     }
55752   }
55753   jresult = (int)result;
55754   return jresult;
55755 }
55756
55757
55758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55759   Dali::Application *arg1 = (Dali::Application *) 0 ;
55760   float arg2 ;
55761
55762   arg1 = (Dali::Application *)jarg1;
55763   arg2 = (float)jarg2;
55764   {
55765     try {
55766       (arg1)->SetStereoBase(arg2);
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55774       };
55775     } catch (...) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55778       };
55779     }
55780   }
55781 }
55782
55783
55784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55785   float jresult ;
55786   Dali::Application *arg1 = (Dali::Application *) 0 ;
55787   float result;
55788
55789   arg1 = (Dali::Application *)jarg1;
55790   {
55791     try {
55792       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55793     } catch (std::out_of_range& e) {
55794       {
55795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (std::exception& e) {
55798       {
55799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (...) {
55802       {
55803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55804       };
55805     }
55806   }
55807   jresult = result;
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55813   void * jresult ;
55814   Dali::Application *arg1 = (Dali::Application *) 0 ;
55815   Dali::Application::AppSignalType *result = 0 ;
55816
55817   arg1 = (Dali::Application *)jarg1;
55818   {
55819     try {
55820       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55821     } catch (std::out_of_range& e) {
55822       {
55823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (std::exception& e) {
55826       {
55827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55832       };
55833     }
55834   }
55835   jresult = (void *)result;
55836   return jresult;
55837 }
55838
55839
55840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55841   void * jresult ;
55842   Dali::Application *arg1 = (Dali::Application *) 0 ;
55843   Dali::Application::AppSignalType *result = 0 ;
55844
55845   arg1 = (Dali::Application *)jarg1;
55846   {
55847     try {
55848       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55849     } catch (std::out_of_range& e) {
55850       {
55851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55852       };
55853     } catch (std::exception& e) {
55854       {
55855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55856       };
55857     } catch (...) {
55858       {
55859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55860       };
55861     }
55862   }
55863   jresult = (void *)result;
55864   return jresult;
55865 }
55866
55867
55868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55869   void * jresult ;
55870   Dali::Application *arg1 = (Dali::Application *) 0 ;
55871   Dali::Application::AppSignalType *result = 0 ;
55872
55873   arg1 = (Dali::Application *)jarg1;
55874   {
55875     try {
55876       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55877     } catch (std::out_of_range& e) {
55878       {
55879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55880       };
55881     } catch (std::exception& e) {
55882       {
55883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55884       };
55885     } catch (...) {
55886       {
55887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55888       };
55889     }
55890   }
55891   jresult = (void *)result;
55892   return jresult;
55893 }
55894
55895
55896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55897   void * jresult ;
55898   Dali::Application *arg1 = (Dali::Application *) 0 ;
55899   Dali::Application::AppSignalType *result = 0 ;
55900
55901   arg1 = (Dali::Application *)jarg1;
55902   {
55903     try {
55904       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55905     } catch (std::out_of_range& e) {
55906       {
55907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55908       };
55909     } catch (std::exception& e) {
55910       {
55911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (...) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55916       };
55917     }
55918   }
55919   jresult = (void *)result;
55920   return jresult;
55921 }
55922
55923
55924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55925   void * jresult ;
55926   Dali::Application *arg1 = (Dali::Application *) 0 ;
55927   Dali::Application::AppSignalType *result = 0 ;
55928
55929   arg1 = (Dali::Application *)jarg1;
55930   {
55931     try {
55932       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55933     } catch (std::out_of_range& e) {
55934       {
55935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55936       };
55937     } catch (std::exception& e) {
55938       {
55939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55940       };
55941     } catch (...) {
55942       {
55943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55944       };
55945     }
55946   }
55947   jresult = (void *)result;
55948   return jresult;
55949 }
55950
55951
55952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55953   void * jresult ;
55954   Dali::Application *arg1 = (Dali::Application *) 0 ;
55955   Dali::Application::AppSignalType *result = 0 ;
55956
55957   arg1 = (Dali::Application *)jarg1;
55958   {
55959     try {
55960       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55961     } catch (std::out_of_range& e) {
55962       {
55963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55964       };
55965     } catch (std::exception& e) {
55966       {
55967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55968       };
55969     } catch (...) {
55970       {
55971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55972       };
55973     }
55974   }
55975   jresult = (void *)result;
55976   return jresult;
55977 }
55978
55979
55980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55981   void * jresult ;
55982   Dali::Application *arg1 = (Dali::Application *) 0 ;
55983   Dali::Application::AppControlSignalType *result = 0 ;
55984
55985   arg1 = (Dali::Application *)jarg1;
55986   {
55987     try {
55988       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55989     } catch (std::out_of_range& e) {
55990       {
55991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55992       };
55993     } catch (std::exception& e) {
55994       {
55995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55996       };
55997     } catch (...) {
55998       {
55999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56000       };
56001     }
56002   }
56003   jresult = (void *)result;
56004   return jresult;
56005 }
56006
56007
56008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
56009   void * jresult ;
56010   Dali::Application *arg1 = (Dali::Application *) 0 ;
56011   Dali::Application::AppSignalType *result = 0 ;
56012
56013   arg1 = (Dali::Application *)jarg1;
56014   {
56015     try {
56016       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56017     } catch (std::out_of_range& e) {
56018       {
56019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (std::exception& e) {
56022       {
56023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56028       };
56029     }
56030   }
56031   jresult = (void *)result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
56037   void * jresult ;
56038   Dali::Application *arg1 = (Dali::Application *) 0 ;
56039   Dali::Application::AppSignalType *result = 0 ;
56040
56041   arg1 = (Dali::Application *)jarg1;
56042   {
56043     try {
56044       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (...) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56056       };
56057     }
56058   }
56059   jresult = (void *)result;
56060   return jresult;
56061 }
56062
56063
56064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
56065   void * jresult ;
56066   Dali::Application *arg1 = (Dali::Application *) 0 ;
56067   Dali::Application::AppSignalType *result = 0 ;
56068
56069   arg1 = (Dali::Application *)jarg1;
56070   {
56071     try {
56072       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56073     } catch (std::out_of_range& e) {
56074       {
56075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56076       };
56077     } catch (std::exception& e) {
56078       {
56079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56080       };
56081     } catch (...) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56084       };
56085     }
56086   }
56087   jresult = (void *)result;
56088   return jresult;
56089 }
56090
56091
56092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56093   void * jresult ;
56094   Dali::Application *arg1 = (Dali::Application *) 0 ;
56095   Dali::Application::AppSignalType *result = 0 ;
56096
56097   arg1 = (Dali::Application *)jarg1;
56098   {
56099     try {
56100       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (...) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56112       };
56113     }
56114   }
56115   jresult = (void *)result;
56116   return jresult;
56117 }
56118
56119
56120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56121   unsigned int jresult ;
56122   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56123   bool result;
56124
56125   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56126   {
56127     try {
56128       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56129     } catch (std::out_of_range& e) {
56130       {
56131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56132       };
56133     } catch (std::exception& e) {
56134       {
56135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (...) {
56138       {
56139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56140       };
56141     }
56142   }
56143   jresult = result;
56144   return jresult;
56145 }
56146
56147
56148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56149   unsigned long jresult ;
56150   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56151   std::size_t result;
56152
56153   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56154   {
56155     try {
56156       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56157     } catch (std::out_of_range& e) {
56158       {
56159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56160       };
56161     } catch (std::exception& e) {
56162       {
56163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56164       };
56165     } catch (...) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56168       };
56169     }
56170   }
56171   jresult = (unsigned long)result;
56172   return jresult;
56173 }
56174
56175
56176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56177   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56178   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56179
56180   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56181   arg2 = (void (*)(Dali::Application &))jarg2;
56182   {
56183     try {
56184       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56196       };
56197     }
56198   }
56199 }
56200
56201
56202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56203   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56204   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56205
56206   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56207   arg2 = (void (*)(Dali::Application &))jarg2;
56208   {
56209     try {
56210       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56211     } catch (std::out_of_range& e) {
56212       {
56213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (std::exception& e) {
56216       {
56217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56222       };
56223     }
56224   }
56225 }
56226
56227
56228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56229   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56230   Dali::Application *arg2 = 0 ;
56231
56232   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56233   arg2 = (Dali::Application *)jarg2;
56234   if (!arg2) {
56235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56236     return ;
56237   }
56238   {
56239     try {
56240       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56241     } catch (std::out_of_range& e) {
56242       {
56243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56244       };
56245     } catch (std::exception& e) {
56246       {
56247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56252       };
56253     }
56254   }
56255 }
56256
56257
56258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56259   void * jresult ;
56260   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56261
56262   {
56263     try {
56264       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56265     } catch (std::out_of_range& e) {
56266       {
56267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (std::exception& e) {
56270       {
56271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279   jresult = (void *)result;
56280   return jresult;
56281 }
56282
56283
56284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56285   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56286
56287   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56288   {
56289     try {
56290       delete arg1;
56291     } catch (std::out_of_range& e) {
56292       {
56293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56294       };
56295     } catch (std::exception& e) {
56296       {
56297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56298       };
56299     } catch (...) {
56300       {
56301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56302       };
56303     }
56304   }
56305 }
56306
56307
56308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56309   unsigned int jresult ;
56310   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56311   bool result;
56312
56313   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56314   {
56315     try {
56316       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56317     } catch (std::out_of_range& e) {
56318       {
56319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56320       };
56321     } catch (std::exception& e) {
56322       {
56323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56324       };
56325     } catch (...) {
56326       {
56327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56328       };
56329     }
56330   }
56331   jresult = result;
56332   return jresult;
56333 }
56334
56335
56336 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56337   unsigned long jresult ;
56338   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56339   std::size_t result;
56340
56341   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56342   {
56343     try {
56344       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56345     } catch (std::out_of_range& e) {
56346       {
56347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (std::exception& e) {
56350       {
56351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56352       };
56353     } catch (...) {
56354       {
56355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56356       };
56357     }
56358   }
56359   jresult = (unsigned long)result;
56360   return jresult;
56361 }
56362
56363
56364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56365   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56366   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56367
56368   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56369   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56370   {
56371     try {
56372       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56373     } catch (std::out_of_range& e) {
56374       {
56375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56376       };
56377     } catch (std::exception& e) {
56378       {
56379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56380       };
56381     } catch (...) {
56382       {
56383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56384       };
56385     }
56386   }
56387 }
56388
56389
56390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56391   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56392   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56393
56394   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56395   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56396   {
56397     try {
56398       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56399     } catch (std::out_of_range& e) {
56400       {
56401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (std::exception& e) {
56404       {
56405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56410       };
56411     }
56412   }
56413 }
56414
56415
56416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56417   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56418   Dali::Application *arg2 = 0 ;
56419   void *arg3 = (void *) 0 ;
56420
56421   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56422   arg2 = (Dali::Application *)jarg2;
56423   if (!arg2) {
56424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56425     return ;
56426   }
56427   arg3 = jarg3;
56428   {
56429     try {
56430       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56431     } catch (std::out_of_range& e) {
56432       {
56433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56434       };
56435     } catch (std::exception& e) {
56436       {
56437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56442       };
56443     }
56444   }
56445 }
56446
56447
56448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56449   void * jresult ;
56450   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56451
56452   {
56453     try {
56454       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56466       };
56467     }
56468   }
56469   jresult = (void *)result;
56470   return jresult;
56471 }
56472
56473
56474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56475   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56476
56477   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56478   {
56479     try {
56480       delete arg1;
56481     } catch (std::out_of_range& e) {
56482       {
56483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56484       };
56485     } catch (std::exception& e) {
56486       {
56487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (...) {
56490       {
56491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56492       };
56493     }
56494   }
56495 }
56496
56497
56498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56499   unsigned int jresult ;
56500   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56501   bool result;
56502
56503   arg1 = (Dali::Signal< bool () > *)jarg1;
56504   {
56505     try {
56506       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56507     } catch (std::out_of_range& e) {
56508       {
56509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56510       };
56511     } catch (std::exception& e) {
56512       {
56513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56514       };
56515     } catch (...) {
56516       {
56517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56518       };
56519     }
56520   }
56521   jresult = result;
56522   return jresult;
56523 }
56524
56525
56526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56527   unsigned long jresult ;
56528   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56529   std::size_t result;
56530
56531   arg1 = (Dali::Signal< bool () > *)jarg1;
56532   {
56533     try {
56534       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56535     } catch (std::out_of_range& e) {
56536       {
56537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56538       };
56539     } catch (std::exception& e) {
56540       {
56541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56542       };
56543     } catch (...) {
56544       {
56545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56546       };
56547     }
56548   }
56549   jresult = (unsigned long)result;
56550   return jresult;
56551 }
56552
56553
56554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56555   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56556   bool (*arg2)() = (bool (*)()) 0 ;
56557
56558   arg1 = (Dali::Signal< bool () > *)jarg1;
56559   arg2 = (bool (*)())jarg2;
56560   {
56561     try {
56562       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56563     } catch (std::out_of_range& e) {
56564       {
56565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56566       };
56567     } catch (std::exception& e) {
56568       {
56569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56570       };
56571     } catch (...) {
56572       {
56573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56574       };
56575     }
56576   }
56577 }
56578
56579
56580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56581   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56582   bool (*arg2)() = (bool (*)()) 0 ;
56583
56584   arg1 = (Dali::Signal< bool () > *)jarg1;
56585   arg2 = (bool (*)())jarg2;
56586   {
56587     try {
56588       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56589     } catch (std::out_of_range& e) {
56590       {
56591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56592       };
56593     } catch (std::exception& e) {
56594       {
56595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56600       };
56601     }
56602   }
56603 }
56604
56605
56606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56607   unsigned int jresult ;
56608   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56609   bool result;
56610
56611   arg1 = (Dali::Signal< bool () > *)jarg1;
56612   {
56613     try {
56614       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56615     } catch (std::out_of_range& e) {
56616       {
56617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56618       };
56619     } catch (std::exception& e) {
56620       {
56621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56622       };
56623     } catch (...) {
56624       {
56625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56626       };
56627     }
56628   }
56629   jresult = result;
56630   return jresult;
56631 }
56632
56633
56634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56635   void * jresult ;
56636   Dali::Signal< bool () > *result = 0 ;
56637
56638   {
56639     try {
56640       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (...) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56652       };
56653     }
56654   }
56655   jresult = (void *)result;
56656   return jresult;
56657 }
56658
56659
56660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56661   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56662
56663   arg1 = (Dali::Signal< bool () > *)jarg1;
56664   {
56665     try {
56666       delete arg1;
56667     } catch (std::out_of_range& e) {
56668       {
56669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56670       };
56671     } catch (std::exception& e) {
56672       {
56673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56674       };
56675     } catch (...) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56678       };
56679     }
56680   }
56681 }
56682
56683
56684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56685   unsigned int jresult ;
56686   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56687   bool result;
56688
56689   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56690   {
56691     try {
56692       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (...) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56704       };
56705     }
56706   }
56707   jresult = result;
56708   return jresult;
56709 }
56710
56711
56712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56713   unsigned long jresult ;
56714   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56715   std::size_t result;
56716
56717   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56718   {
56719     try {
56720       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56721     } catch (std::out_of_range& e) {
56722       {
56723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56724       };
56725     } catch (std::exception& e) {
56726       {
56727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56732       };
56733     }
56734   }
56735   jresult = (unsigned long)result;
56736   return jresult;
56737 }
56738
56739
56740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56741   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56742   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56743
56744   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56745   arg2 = (void (*)(bool))jarg2;
56746   {
56747     try {
56748       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56749     } catch (std::out_of_range& e) {
56750       {
56751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56752       };
56753     } catch (std::exception& e) {
56754       {
56755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56756       };
56757     } catch (...) {
56758       {
56759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56760       };
56761     }
56762   }
56763 }
56764
56765
56766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56767   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56768   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56769
56770   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56771   arg2 = (void (*)(bool))jarg2;
56772   {
56773     try {
56774       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56775     } catch (std::out_of_range& e) {
56776       {
56777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (std::exception& e) {
56780       {
56781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (...) {
56784       {
56785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56786       };
56787     }
56788   }
56789 }
56790
56791
56792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56793   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56794   bool arg2 ;
56795
56796   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56797   arg2 = jarg2 ? true : false;
56798   {
56799     try {
56800       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56801     } catch (std::out_of_range& e) {
56802       {
56803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56804       };
56805     } catch (std::exception& e) {
56806       {
56807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56808       };
56809     } catch (...) {
56810       {
56811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56812       };
56813     }
56814   }
56815 }
56816
56817
56818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56819   void * jresult ;
56820   Dali::Signal< void (bool) > *result = 0 ;
56821
56822   {
56823     try {
56824       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56825     } catch (std::out_of_range& e) {
56826       {
56827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56828       };
56829     } catch (std::exception& e) {
56830       {
56831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (...) {
56834       {
56835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56836       };
56837     }
56838   }
56839   jresult = (void *)result;
56840   return jresult;
56841 }
56842
56843
56844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56845   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56846
56847   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56848   {
56849     try {
56850       delete arg1;
56851     } catch (std::out_of_range& e) {
56852       {
56853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56854       };
56855     } catch (std::exception& e) {
56856       {
56857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56858       };
56859     } catch (...) {
56860       {
56861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56862       };
56863     }
56864   }
56865 }
56866
56867
56868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56869   int jresult ;
56870   int result;
56871
56872   {
56873     try {
56874       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56875     } catch (std::out_of_range& e) {
56876       {
56877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56878       };
56879     } catch (std::exception& e) {
56880       {
56881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56886       };
56887     }
56888   }
56889   jresult = (int)result;
56890   return jresult;
56891 }
56892
56893
56894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56895   int jresult ;
56896   int result;
56897
56898   {
56899     try {
56900       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56901     } catch (std::out_of_range& e) {
56902       {
56903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56904       };
56905     } catch (std::exception& e) {
56906       {
56907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56908       };
56909     } catch (...) {
56910       {
56911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56912       };
56913     }
56914   }
56915   jresult = (int)result;
56916   return jresult;
56917 }
56918
56919
56920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56921   int jresult ;
56922   int result;
56923
56924   {
56925     try {
56926       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56927     } catch (std::out_of_range& e) {
56928       {
56929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (std::exception& e) {
56932       {
56933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56934       };
56935     } catch (...) {
56936       {
56937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56938       };
56939     }
56940   }
56941   jresult = (int)result;
56942   return jresult;
56943 }
56944
56945
56946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56947   int jresult ;
56948   int result;
56949
56950   {
56951     try {
56952       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56964       };
56965     }
56966   }
56967   jresult = (int)result;
56968   return jresult;
56969 }
56970
56971
56972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56973   int jresult ;
56974   int result;
56975
56976   {
56977     try {
56978       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56979     } catch (std::out_of_range& e) {
56980       {
56981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (std::exception& e) {
56984       {
56985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56986       };
56987     } catch (...) {
56988       {
56989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56990       };
56991     }
56992   }
56993   jresult = (int)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56999   int jresult ;
57000   int result;
57001
57002   {
57003     try {
57004       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57005     } catch (std::out_of_range& e) {
57006       {
57007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (std::exception& e) {
57010       {
57011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019   jresult = (int)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57025   int jresult ;
57026   int result;
57027
57028   {
57029     try {
57030       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57031     } catch (std::out_of_range& e) {
57032       {
57033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (std::exception& e) {
57036       {
57037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57042       };
57043     }
57044   }
57045   jresult = (int)result;
57046   return jresult;
57047 }
57048
57049
57050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57051   int jresult ;
57052   int result;
57053
57054   {
57055     try {
57056       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57057     } catch (std::out_of_range& e) {
57058       {
57059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57060       };
57061     } catch (std::exception& e) {
57062       {
57063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57064       };
57065     } catch (...) {
57066       {
57067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57068       };
57069     }
57070   }
57071   jresult = (int)result;
57072   return jresult;
57073 }
57074
57075
57076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57077   int jresult ;
57078   int result;
57079
57080   {
57081     try {
57082       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57083     } catch (std::out_of_range& e) {
57084       {
57085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (std::exception& e) {
57088       {
57089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57090       };
57091     } catch (...) {
57092       {
57093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57094       };
57095     }
57096   }
57097   jresult = (int)result;
57098   return jresult;
57099 }
57100
57101
57102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57103   int jresult ;
57104   int result;
57105
57106   {
57107     try {
57108       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57109     } catch (std::out_of_range& e) {
57110       {
57111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (std::exception& e) {
57114       {
57115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57116       };
57117     } catch (...) {
57118       {
57119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57120       };
57121     }
57122   }
57123   jresult = (int)result;
57124   return jresult;
57125 }
57126
57127
57128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57129   int jresult ;
57130   int result;
57131
57132   {
57133     try {
57134       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57135     } catch (std::out_of_range& e) {
57136       {
57137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (std::exception& e) {
57140       {
57141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57142       };
57143     } catch (...) {
57144       {
57145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57146       };
57147     }
57148   }
57149   jresult = (int)result;
57150   return jresult;
57151 }
57152
57153
57154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57155   int jresult ;
57156   int result;
57157
57158   {
57159     try {
57160       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57161     } catch (std::out_of_range& e) {
57162       {
57163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (std::exception& e) {
57166       {
57167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57168       };
57169     } catch (...) {
57170       {
57171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57172       };
57173     }
57174   }
57175   jresult = (int)result;
57176   return jresult;
57177 }
57178
57179
57180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57181   int jresult ;
57182   int result;
57183
57184   {
57185     try {
57186       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57187     } catch (std::out_of_range& e) {
57188       {
57189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (std::exception& e) {
57192       {
57193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57194       };
57195     } catch (...) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57198       };
57199     }
57200   }
57201   jresult = (int)result;
57202   return jresult;
57203 }
57204
57205
57206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57207   int jresult ;
57208   int result;
57209
57210   {
57211     try {
57212       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57213     } catch (std::out_of_range& e) {
57214       {
57215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57216       };
57217     } catch (std::exception& e) {
57218       {
57219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57220       };
57221     } catch (...) {
57222       {
57223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57224       };
57225     }
57226   }
57227   jresult = (int)result;
57228   return jresult;
57229 }
57230
57231
57232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57233   int jresult ;
57234   int result;
57235
57236   {
57237     try {
57238       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57239     } catch (std::out_of_range& e) {
57240       {
57241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57242       };
57243     } catch (std::exception& e) {
57244       {
57245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57246       };
57247     } catch (...) {
57248       {
57249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57250       };
57251     }
57252   }
57253   jresult = (int)result;
57254   return jresult;
57255 }
57256
57257
57258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57259   int jresult ;
57260   int result;
57261
57262   {
57263     try {
57264       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57265     } catch (std::out_of_range& e) {
57266       {
57267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (std::exception& e) {
57270       {
57271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57276       };
57277     }
57278   }
57279   jresult = (int)result;
57280   return jresult;
57281 }
57282
57283
57284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57285   int jresult ;
57286   int result;
57287
57288   {
57289     try {
57290       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57291     } catch (std::out_of_range& e) {
57292       {
57293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57294       };
57295     } catch (std::exception& e) {
57296       {
57297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57298       };
57299     } catch (...) {
57300       {
57301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57302       };
57303     }
57304   }
57305   jresult = (int)result;
57306   return jresult;
57307 }
57308
57309
57310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57311   int jresult ;
57312   int result;
57313
57314   {
57315     try {
57316       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57317     } catch (std::out_of_range& e) {
57318       {
57319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (std::exception& e) {
57322       {
57323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57328       };
57329     }
57330   }
57331   jresult = (int)result;
57332   return jresult;
57333 }
57334
57335
57336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57337   int jresult ;
57338   int result;
57339
57340   {
57341     try {
57342       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57343     } catch (std::out_of_range& e) {
57344       {
57345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57346       };
57347     } catch (std::exception& e) {
57348       {
57349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57350       };
57351     } catch (...) {
57352       {
57353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57354       };
57355     }
57356   }
57357   jresult = (int)result;
57358   return jresult;
57359 }
57360
57361
57362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57363   int jresult ;
57364   int result;
57365
57366   {
57367     try {
57368       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57369     } catch (std::out_of_range& e) {
57370       {
57371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (std::exception& e) {
57374       {
57375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (...) {
57378       {
57379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57380       };
57381     }
57382   }
57383   jresult = (int)result;
57384   return jresult;
57385 }
57386
57387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57388   int jresult ;
57389   int result;
57390
57391   {
57392     try {
57393       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
57394     } catch (std::out_of_range& e) {
57395       {
57396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57397       };
57398     } catch (std::exception& e) {
57399       {
57400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57401       };
57402     } catch (...) {
57403       {
57404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57405       };
57406     }
57407   }
57408   jresult = (int)result;
57409   return jresult;
57410 }
57411
57412
57413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57414   int jresult ;
57415   int result;
57416
57417   {
57418     try {
57419       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57420     } catch (std::out_of_range& e) {
57421       {
57422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (std::exception& e) {
57425       {
57426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57427       };
57428     } catch (...) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57431       };
57432     }
57433   }
57434   jresult = (int)result;
57435   return jresult;
57436 }
57437
57438
57439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57440   int jresult ;
57441   int result;
57442
57443   {
57444     try {
57445       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57446     } catch (std::out_of_range& e) {
57447       {
57448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (std::exception& e) {
57451       {
57452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57453       };
57454     } catch (...) {
57455       {
57456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57457       };
57458     }
57459   }
57460   jresult = (int)result;
57461   return jresult;
57462 }
57463
57464
57465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57466   int jresult ;
57467   int result;
57468
57469   {
57470     try {
57471       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57472     } catch (std::out_of_range& e) {
57473       {
57474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57475       };
57476     } catch (std::exception& e) {
57477       {
57478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57479       };
57480     } catch (...) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57483       };
57484     }
57485   }
57486   jresult = (int)result;
57487   return jresult;
57488 }
57489
57490
57491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57492   int jresult ;
57493   int result;
57494
57495   {
57496     try {
57497       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57498     } catch (std::out_of_range& e) {
57499       {
57500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (std::exception& e) {
57503       {
57504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57505       };
57506     } catch (...) {
57507       {
57508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57509       };
57510     }
57511   }
57512   jresult = (int)result;
57513   return jresult;
57514 }
57515
57516
57517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57518   int jresult ;
57519   int result;
57520
57521   {
57522     try {
57523       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57524     } catch (std::out_of_range& e) {
57525       {
57526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (std::exception& e) {
57529       {
57530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (...) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57535       };
57536     }
57537   }
57538   jresult = (int)result;
57539   return jresult;
57540 }
57541
57542
57543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57544   int jresult ;
57545   int result;
57546
57547   {
57548     try {
57549       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57550     } catch (std::out_of_range& e) {
57551       {
57552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (std::exception& e) {
57555       {
57556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57557       };
57558     } catch (...) {
57559       {
57560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57561       };
57562     }
57563   }
57564   jresult = (int)result;
57565   return jresult;
57566 }
57567
57568
57569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57570   int jresult ;
57571   int result;
57572
57573   {
57574     try {
57575       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57576     } catch (std::out_of_range& e) {
57577       {
57578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (std::exception& e) {
57581       {
57582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57583       };
57584     } catch (...) {
57585       {
57586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57587       };
57588     }
57589   }
57590   jresult = (int)result;
57591   return jresult;
57592 }
57593
57594
57595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57596   int jresult ;
57597   int result;
57598
57599   {
57600     try {
57601       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57602     } catch (std::out_of_range& e) {
57603       {
57604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (std::exception& e) {
57607       {
57608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57609       };
57610     } catch (...) {
57611       {
57612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57613       };
57614     }
57615   }
57616   jresult = (int)result;
57617   return jresult;
57618 }
57619
57620
57621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57622   int jresult ;
57623   int result;
57624
57625   {
57626     try {
57627       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57628     } catch (std::out_of_range& e) {
57629       {
57630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57631       };
57632     } catch (std::exception& e) {
57633       {
57634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57635       };
57636     } catch (...) {
57637       {
57638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57639       };
57640     }
57641   }
57642   jresult = (int)result;
57643   return jresult;
57644 }
57645
57646
57647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57648   int jresult ;
57649   int result;
57650
57651   {
57652     try {
57653       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57661       };
57662     } catch (...) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57665       };
57666     }
57667   }
57668   jresult = (int)result;
57669   return jresult;
57670 }
57671
57672
57673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57674   int jresult ;
57675   int result;
57676
57677   {
57678     try {
57679       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57680     } catch (std::out_of_range& e) {
57681       {
57682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57683       };
57684     } catch (std::exception& e) {
57685       {
57686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57687       };
57688     } catch (...) {
57689       {
57690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57691       };
57692     }
57693   }
57694   jresult = (int)result;
57695   return jresult;
57696 }
57697
57698
57699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57700   int jresult ;
57701   int result;
57702
57703   {
57704     try {
57705       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (...) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57717       };
57718     }
57719   }
57720   jresult = (int)result;
57721   return jresult;
57722 }
57723
57724
57725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57726   int jresult ;
57727   int result;
57728
57729   {
57730     try {
57731       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57732     } catch (std::out_of_range& e) {
57733       {
57734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (std::exception& e) {
57737       {
57738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57739       };
57740     } catch (...) {
57741       {
57742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57743       };
57744     }
57745   }
57746   jresult = (int)result;
57747   return jresult;
57748 }
57749
57750
57751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57752   int jresult ;
57753   int result;
57754
57755   {
57756     try {
57757       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57758     } catch (std::out_of_range& e) {
57759       {
57760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (std::exception& e) {
57763       {
57764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57765       };
57766     } catch (...) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57769       };
57770     }
57771   }
57772   jresult = (int)result;
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57778   int jresult ;
57779   int result;
57780
57781   {
57782     try {
57783       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57784     } catch (std::out_of_range& e) {
57785       {
57786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (std::exception& e) {
57789       {
57790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (...) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57795       };
57796     }
57797   }
57798   jresult = (int)result;
57799   return jresult;
57800 }
57801
57802
57803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57804   int jresult ;
57805   int result;
57806
57807   {
57808     try {
57809       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57810     } catch (std::out_of_range& e) {
57811       {
57812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57813       };
57814     } catch (std::exception& e) {
57815       {
57816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57817       };
57818     } catch (...) {
57819       {
57820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57821       };
57822     }
57823   }
57824   jresult = (int)result;
57825   return jresult;
57826 }
57827
57828
57829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57830   int jresult ;
57831   int result;
57832
57833   {
57834     try {
57835       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57836     } catch (std::out_of_range& e) {
57837       {
57838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (std::exception& e) {
57841       {
57842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (...) {
57845       {
57846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57847       };
57848     }
57849   }
57850   jresult = (int)result;
57851   return jresult;
57852 }
57853
57854
57855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57856   int jresult ;
57857   int result;
57858
57859   {
57860     try {
57861       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57862     } catch (std::out_of_range& e) {
57863       {
57864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57865       };
57866     } catch (std::exception& e) {
57867       {
57868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57869       };
57870     } catch (...) {
57871       {
57872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57873       };
57874     }
57875   }
57876   jresult = (int)result;
57877   return jresult;
57878 }
57879
57880
57881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57882   int jresult ;
57883   int result;
57884
57885   {
57886     try {
57887       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57888     } catch (std::out_of_range& e) {
57889       {
57890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (std::exception& e) {
57893       {
57894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57899       };
57900     }
57901   }
57902   jresult = (int)result;
57903   return jresult;
57904 }
57905
57906
57907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57908   int jresult ;
57909   int result;
57910
57911   {
57912     try {
57913       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57914     } catch (std::out_of_range& e) {
57915       {
57916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (std::exception& e) {
57919       {
57920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57921       };
57922     } catch (...) {
57923       {
57924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57925       };
57926     }
57927   }
57928   jresult = (int)result;
57929   return jresult;
57930 }
57931
57932
57933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57934   int jresult ;
57935   int result;
57936
57937   {
57938     try {
57939       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57940     } catch (std::out_of_range& e) {
57941       {
57942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (std::exception& e) {
57945       {
57946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57947       };
57948     } catch (...) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57951       };
57952     }
57953   }
57954   jresult = (int)result;
57955   return jresult;
57956 }
57957
57958
57959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57960   int jresult ;
57961   int result;
57962
57963   {
57964     try {
57965       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57966     } catch (std::out_of_range& e) {
57967       {
57968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (std::exception& e) {
57971       {
57972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57973       };
57974     } catch (...) {
57975       {
57976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57977       };
57978     }
57979   }
57980   jresult = (int)result;
57981   return jresult;
57982 }
57983
57984
57985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57986   int jresult ;
57987   int result;
57988
57989   {
57990     try {
57991       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57992     } catch (std::out_of_range& e) {
57993       {
57994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (std::exception& e) {
57997       {
57998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57999       };
58000     } catch (...) {
58001       {
58002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58003       };
58004     }
58005   }
58006   jresult = (int)result;
58007   return jresult;
58008 }
58009
58010
58011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58012   int jresult ;
58013   int result;
58014
58015   {
58016     try {
58017       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58018     } catch (std::out_of_range& e) {
58019       {
58020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (std::exception& e) {
58023       {
58024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58025       };
58026     } catch (...) {
58027       {
58028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58029       };
58030     }
58031   }
58032   jresult = (int)result;
58033   return jresult;
58034 }
58035
58036
58037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58038   int jresult ;
58039   int result;
58040
58041   {
58042     try {
58043       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58051       };
58052     } catch (...) {
58053       {
58054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58055       };
58056     }
58057   }
58058   jresult = (int)result;
58059   return jresult;
58060 }
58061
58062
58063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58064   int jresult ;
58065   int result;
58066
58067   {
58068     try {
58069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58070     } catch (std::out_of_range& e) {
58071       {
58072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (std::exception& e) {
58075       {
58076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58077       };
58078     } catch (...) {
58079       {
58080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58081       };
58082     }
58083   }
58084   jresult = (int)result;
58085   return jresult;
58086 }
58087
58088
58089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58090   int jresult ;
58091   int result;
58092
58093   {
58094     try {
58095       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58096     } catch (std::out_of_range& e) {
58097       {
58098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58099       };
58100     } catch (std::exception& e) {
58101       {
58102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58103       };
58104     } catch (...) {
58105       {
58106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58107       };
58108     }
58109   }
58110   jresult = (int)result;
58111   return jresult;
58112 }
58113
58114
58115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58116   int jresult ;
58117   int result;
58118
58119   {
58120     try {
58121       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58122     } catch (std::out_of_range& e) {
58123       {
58124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (std::exception& e) {
58127       {
58128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58129       };
58130     } catch (...) {
58131       {
58132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58133       };
58134     }
58135   }
58136   jresult = (int)result;
58137   return jresult;
58138 }
58139
58140
58141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58142   int jresult ;
58143   int result;
58144
58145   {
58146     try {
58147       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58148     } catch (std::out_of_range& e) {
58149       {
58150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (std::exception& e) {
58153       {
58154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58155       };
58156     } catch (...) {
58157       {
58158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58159       };
58160     }
58161   }
58162   jresult = (int)result;
58163   return jresult;
58164 }
58165
58166
58167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58168   int jresult ;
58169   int result;
58170
58171   {
58172     try {
58173       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58174     } catch (std::out_of_range& e) {
58175       {
58176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (std::exception& e) {
58179       {
58180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58181       };
58182     } catch (...) {
58183       {
58184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58185       };
58186     }
58187   }
58188   jresult = (int)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58194   int jresult ;
58195   int result;
58196
58197   {
58198     try {
58199       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58200     } catch (std::out_of_range& e) {
58201       {
58202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (std::exception& e) {
58205       {
58206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58207       };
58208     } catch (...) {
58209       {
58210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58211       };
58212     }
58213   }
58214   jresult = (int)result;
58215   return jresult;
58216 }
58217
58218
58219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58220   int jresult ;
58221   int result;
58222
58223   {
58224     try {
58225       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58226     } catch (std::out_of_range& e) {
58227       {
58228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (std::exception& e) {
58231       {
58232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58233       };
58234     } catch (...) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58237       };
58238     }
58239   }
58240   jresult = (int)result;
58241   return jresult;
58242 }
58243
58244
58245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58246   int jresult ;
58247   int result;
58248
58249   {
58250     try {
58251       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (...) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58263       };
58264     }
58265   }
58266   jresult = (int)result;
58267   return jresult;
58268 }
58269
58270
58271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58272   int jresult ;
58273   int result;
58274
58275   {
58276     try {
58277       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58278     } catch (std::out_of_range& e) {
58279       {
58280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (std::exception& e) {
58283       {
58284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58285       };
58286     } catch (...) {
58287       {
58288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58289       };
58290     }
58291   }
58292   jresult = (int)result;
58293   return jresult;
58294 }
58295
58296
58297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58298   int jresult ;
58299   int result;
58300
58301   {
58302     try {
58303       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58304     } catch (std::out_of_range& e) {
58305       {
58306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (std::exception& e) {
58309       {
58310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58311       };
58312     } catch (...) {
58313       {
58314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58315       };
58316     }
58317   }
58318   jresult = (int)result;
58319   return jresult;
58320 }
58321
58322
58323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58324   int jresult ;
58325   int result;
58326
58327   {
58328     try {
58329       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
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 = (int)result;
58345   return jresult;
58346 }
58347
58348
58349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58350   int jresult ;
58351   int result;
58352
58353   {
58354     try {
58355       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
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 = (int)result;
58371   return jresult;
58372 }
58373
58374
58375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58376   void * jresult ;
58377   Dali::Toolkit::Builder *result = 0 ;
58378
58379   {
58380     try {
58381       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58382     } catch (std::out_of_range& e) {
58383       {
58384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (std::exception& e) {
58387       {
58388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (...) {
58391       {
58392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58393       };
58394     }
58395   }
58396   jresult = (void *)result;
58397   return jresult;
58398 }
58399
58400
58401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58402   void * jresult ;
58403   Dali::Toolkit::Builder result;
58404
58405   {
58406     try {
58407       result = Dali::Toolkit::Builder::New();
58408     } catch (std::out_of_range& e) {
58409       {
58410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (std::exception& e) {
58413       {
58414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58415       };
58416     } catch (...) {
58417       {
58418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58419       };
58420     }
58421   }
58422   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58423   return jresult;
58424 }
58425
58426
58427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58428   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58429
58430   arg1 = (Dali::Toolkit::Builder *)jarg1;
58431   {
58432     try {
58433       delete arg1;
58434     } catch (std::out_of_range& e) {
58435       {
58436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58437       };
58438     } catch (std::exception& e) {
58439       {
58440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58445       };
58446     }
58447   }
58448 }
58449
58450
58451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58452   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58453   std::string *arg2 = 0 ;
58454   Dali::Toolkit::Builder::UIFormat arg3 ;
58455
58456   arg1 = (Dali::Toolkit::Builder *)jarg1;
58457   if (!jarg2) {
58458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58459     return ;
58460   }
58461   std::string arg2_str(jarg2);
58462   arg2 = &arg2_str;
58463   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58464   {
58465     try {
58466       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58467     } catch (std::out_of_range& e) {
58468       {
58469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58470       };
58471     } catch (std::exception& e) {
58472       {
58473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58474       };
58475     } catch (...) {
58476       {
58477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58478       };
58479     }
58480   }
58481
58482   //argout typemap for const std::string&
58483
58484 }
58485
58486
58487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58488   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58489   std::string *arg2 = 0 ;
58490
58491   arg1 = (Dali::Toolkit::Builder *)jarg1;
58492   if (!jarg2) {
58493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58494     return ;
58495   }
58496   std::string arg2_str(jarg2);
58497   arg2 = &arg2_str;
58498   {
58499     try {
58500       (arg1)->LoadFromString((std::string const &)*arg2);
58501     } catch (std::out_of_range& e) {
58502       {
58503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58504       };
58505     } catch (std::exception& e) {
58506       {
58507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58508       };
58509     } catch (...) {
58510       {
58511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58512       };
58513     }
58514   }
58515
58516   //argout typemap for const std::string&
58517
58518 }
58519
58520
58521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58522   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58523   Dali::Property::Map *arg2 = 0 ;
58524
58525   arg1 = (Dali::Toolkit::Builder *)jarg1;
58526   arg2 = (Dali::Property::Map *)jarg2;
58527   if (!arg2) {
58528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58529     return ;
58530   }
58531   {
58532     try {
58533       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58534     } catch (std::out_of_range& e) {
58535       {
58536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58537       };
58538     } catch (std::exception& e) {
58539       {
58540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58541       };
58542     } catch (...) {
58543       {
58544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58545       };
58546     }
58547   }
58548 }
58549
58550
58551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58553   std::string *arg2 = 0 ;
58554   Dali::Property::Value *arg3 = 0 ;
58555
58556   arg1 = (Dali::Toolkit::Builder *)jarg1;
58557   if (!jarg2) {
58558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58559     return ;
58560   }
58561   std::string arg2_str(jarg2);
58562   arg2 = &arg2_str;
58563   arg3 = (Dali::Property::Value *)jarg3;
58564   if (!arg3) {
58565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58566     return ;
58567   }
58568   {
58569     try {
58570       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58578       };
58579     } catch (...) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58582       };
58583     }
58584   }
58585
58586   //argout typemap for const std::string&
58587
58588 }
58589
58590
58591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58592   void * jresult ;
58593   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58594   Dali::Property::Map *result = 0 ;
58595
58596   arg1 = (Dali::Toolkit::Builder *)jarg1;
58597   {
58598     try {
58599       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58600     } catch (std::out_of_range& e) {
58601       {
58602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58603       };
58604     } catch (std::exception& e) {
58605       {
58606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58607       };
58608     } catch (...) {
58609       {
58610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58611       };
58612     }
58613   }
58614   jresult = (void *)result;
58615   return jresult;
58616 }
58617
58618
58619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58620   void * jresult ;
58621   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58622   std::string *arg2 = 0 ;
58623   Dali::Property::Value *result = 0 ;
58624
58625   arg1 = (Dali::Toolkit::Builder *)jarg1;
58626   if (!jarg2) {
58627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58628     return 0;
58629   }
58630   std::string arg2_str(jarg2);
58631   arg2 = &arg2_str;
58632   {
58633     try {
58634       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58635     } catch (std::out_of_range& e) {
58636       {
58637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58638       };
58639     } catch (std::exception& e) {
58640       {
58641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58646       };
58647     }
58648   }
58649   jresult = (void *)result;
58650
58651   //argout typemap for const std::string&
58652
58653   return jresult;
58654 }
58655
58656
58657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58658   void * jresult ;
58659   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58660   std::string *arg2 = 0 ;
58661   Dali::Animation result;
58662
58663   arg1 = (Dali::Toolkit::Builder *)jarg1;
58664   if (!jarg2) {
58665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58666     return 0;
58667   }
58668   std::string arg2_str(jarg2);
58669   arg2 = &arg2_str;
58670   {
58671     try {
58672       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58673     } catch (std::out_of_range& e) {
58674       {
58675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58676       };
58677     } catch (std::exception& e) {
58678       {
58679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58680       };
58681     } catch (...) {
58682       {
58683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58684       };
58685     }
58686   }
58687   jresult = new Dali::Animation((const Dali::Animation &)result);
58688
58689   //argout typemap for const std::string&
58690
58691   return jresult;
58692 }
58693
58694
58695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58696   void * jresult ;
58697   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58698   std::string *arg2 = 0 ;
58699   Dali::Property::Map *arg3 = 0 ;
58700   Dali::Animation result;
58701
58702   arg1 = (Dali::Toolkit::Builder *)jarg1;
58703   if (!jarg2) {
58704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58705     return 0;
58706   }
58707   std::string arg2_str(jarg2);
58708   arg2 = &arg2_str;
58709   arg3 = (Dali::Property::Map *)jarg3;
58710   if (!arg3) {
58711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58712     return 0;
58713   }
58714   {
58715     try {
58716       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731   jresult = new Dali::Animation((const Dali::Animation &)result);
58732
58733   //argout typemap for const std::string&
58734
58735   return jresult;
58736 }
58737
58738
58739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58740   void * jresult ;
58741   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58742   std::string *arg2 = 0 ;
58743   Dali::Actor arg3 ;
58744   Dali::Actor *argp3 ;
58745   Dali::Animation result;
58746
58747   arg1 = (Dali::Toolkit::Builder *)jarg1;
58748   if (!jarg2) {
58749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58750     return 0;
58751   }
58752   std::string arg2_str(jarg2);
58753   arg2 = &arg2_str;
58754   argp3 = (Dali::Actor *)jarg3;
58755   if (!argp3) {
58756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58757     return 0;
58758   }
58759   arg3 = *argp3;
58760   {
58761     try {
58762       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58763     } catch (std::out_of_range& e) {
58764       {
58765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (std::exception& e) {
58768       {
58769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777   jresult = new Dali::Animation((const Dali::Animation &)result);
58778
58779   //argout typemap for const std::string&
58780
58781   return jresult;
58782 }
58783
58784
58785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58786   void * jresult ;
58787   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58788   std::string *arg2 = 0 ;
58789   Dali::Property::Map *arg3 = 0 ;
58790   Dali::Actor arg4 ;
58791   Dali::Actor *argp4 ;
58792   Dali::Animation result;
58793
58794   arg1 = (Dali::Toolkit::Builder *)jarg1;
58795   if (!jarg2) {
58796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58797     return 0;
58798   }
58799   std::string arg2_str(jarg2);
58800   arg2 = &arg2_str;
58801   arg3 = (Dali::Property::Map *)jarg3;
58802   if (!arg3) {
58803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58804     return 0;
58805   }
58806   argp4 = (Dali::Actor *)jarg4;
58807   if (!argp4) {
58808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58809     return 0;
58810   }
58811   arg4 = *argp4;
58812   {
58813     try {
58814       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58815     } catch (std::out_of_range& e) {
58816       {
58817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (std::exception& e) {
58820       {
58821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58822       };
58823     } catch (...) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58826       };
58827     }
58828   }
58829   jresult = new Dali::Animation((const Dali::Animation &)result);
58830
58831   //argout typemap for const std::string&
58832
58833   return jresult;
58834 }
58835
58836
58837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58838   void * jresult ;
58839   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58840   std::string *arg2 = 0 ;
58841   Dali::BaseHandle result;
58842
58843   arg1 = (Dali::Toolkit::Builder *)jarg1;
58844   if (!jarg2) {
58845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58846     return 0;
58847   }
58848   std::string arg2_str(jarg2);
58849   arg2 = &arg2_str;
58850   {
58851     try {
58852       result = (arg1)->Create((std::string const &)*arg2);
58853     } catch (std::out_of_range& e) {
58854       {
58855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (std::exception& e) {
58858       {
58859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58860       };
58861     } catch (...) {
58862       {
58863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58864       };
58865     }
58866   }
58867   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58868
58869   //argout typemap for const std::string&
58870
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58876   void * jresult ;
58877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58878   std::string *arg2 = 0 ;
58879   Dali::Property::Map *arg3 = 0 ;
58880   Dali::BaseHandle result;
58881
58882   arg1 = (Dali::Toolkit::Builder *)jarg1;
58883   if (!jarg2) {
58884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58885     return 0;
58886   }
58887   std::string arg2_str(jarg2);
58888   arg2 = &arg2_str;
58889   arg3 = (Dali::Property::Map *)jarg3;
58890   if (!arg3) {
58891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58892     return 0;
58893   }
58894   {
58895     try {
58896       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58904       };
58905     } catch (...) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58908       };
58909     }
58910   }
58911   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58912
58913   //argout typemap for const std::string&
58914
58915   return jresult;
58916 }
58917
58918
58919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58920   void * jresult ;
58921   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58922   std::string *arg2 = 0 ;
58923   Dali::BaseHandle result;
58924
58925   arg1 = (Dali::Toolkit::Builder *)jarg1;
58926   if (!jarg2) {
58927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58928     return 0;
58929   }
58930   std::string arg2_str(jarg2);
58931   arg2 = &arg2_str;
58932   {
58933     try {
58934       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58935     } catch (std::out_of_range& e) {
58936       {
58937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58938       };
58939     } catch (std::exception& e) {
58940       {
58941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58942       };
58943     } catch (...) {
58944       {
58945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58946       };
58947     }
58948   }
58949   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58950
58951   //argout typemap for const std::string&
58952
58953   return jresult;
58954 }
58955
58956
58957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58958   unsigned int jresult ;
58959   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58960   std::string *arg2 = 0 ;
58961   Dali::Handle *arg3 = 0 ;
58962   bool result;
58963
58964   arg1 = (Dali::Toolkit::Builder *)jarg1;
58965   if (!jarg2) {
58966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58967     return 0;
58968   }
58969   std::string arg2_str(jarg2);
58970   arg2 = &arg2_str;
58971   arg3 = (Dali::Handle *)jarg3;
58972   if (!arg3) {
58973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58974     return 0;
58975   }
58976   {
58977     try {
58978       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (...) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58990       };
58991     }
58992   }
58993   jresult = result;
58994
58995   //argout typemap for const std::string&
58996
58997   return jresult;
58998 }
58999
59000
59001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59002   unsigned int jresult ;
59003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59004   Dali::Handle *arg2 = 0 ;
59005   std::string *arg3 = 0 ;
59006   bool result;
59007
59008   arg1 = (Dali::Toolkit::Builder *)jarg1;
59009   arg2 = (Dali::Handle *)jarg2;
59010   if (!arg2) {
59011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59012     return 0;
59013   }
59014   if (!jarg3) {
59015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59016     return 0;
59017   }
59018   std::string arg3_str(jarg3);
59019   arg3 = &arg3_str;
59020   {
59021     try {
59022       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59023     } catch (std::out_of_range& e) {
59024       {
59025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59026       };
59027     } catch (std::exception& e) {
59028       {
59029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59030       };
59031     } catch (...) {
59032       {
59033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59034       };
59035     }
59036   }
59037   jresult = result;
59038
59039   //argout typemap for const std::string&
59040
59041   return jresult;
59042 }
59043
59044
59045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59046   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59047   Dali::Actor arg2 ;
59048   Dali::Actor *argp2 ;
59049
59050   arg1 = (Dali::Toolkit::Builder *)jarg1;
59051   argp2 = (Dali::Actor *)jarg2;
59052   if (!argp2) {
59053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59054     return ;
59055   }
59056   arg2 = *argp2;
59057   {
59058     try {
59059       (arg1)->AddActors(arg2);
59060     } catch (std::out_of_range& e) {
59061       {
59062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59063       };
59064     } catch (std::exception& e) {
59065       {
59066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59067       };
59068     } catch (...) {
59069       {
59070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59071       };
59072     }
59073   }
59074 }
59075
59076
59077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59078   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59079   std::string *arg2 = 0 ;
59080   Dali::Actor arg3 ;
59081   Dali::Actor *argp3 ;
59082
59083   arg1 = (Dali::Toolkit::Builder *)jarg1;
59084   if (!jarg2) {
59085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59086     return ;
59087   }
59088   std::string arg2_str(jarg2);
59089   arg2 = &arg2_str;
59090   argp3 = (Dali::Actor *)jarg3;
59091   if (!argp3) {
59092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59093     return ;
59094   }
59095   arg3 = *argp3;
59096   {
59097     try {
59098       (arg1)->AddActors((std::string const &)*arg2,arg3);
59099     } catch (std::out_of_range& e) {
59100       {
59101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59102       };
59103     } catch (std::exception& e) {
59104       {
59105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59106       };
59107     } catch (...) {
59108       {
59109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59110       };
59111     }
59112   }
59113
59114   //argout typemap for const std::string&
59115
59116 }
59117
59118
59119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59120   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59121   std::string *arg2 = 0 ;
59122
59123   arg1 = (Dali::Toolkit::Builder *)jarg1;
59124   if (!jarg2) {
59125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59126     return ;
59127   }
59128   std::string arg2_str(jarg2);
59129   arg2 = &arg2_str;
59130   {
59131     try {
59132       (arg1)->CreateRenderTask((std::string const &)*arg2);
59133     } catch (std::out_of_range& e) {
59134       {
59135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (std::exception& e) {
59138       {
59139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59140       };
59141     } catch (...) {
59142       {
59143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59144       };
59145     }
59146   }
59147
59148   //argout typemap for const std::string&
59149
59150 }
59151
59152
59153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59154   void * jresult ;
59155   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59156   std::string *arg2 = 0 ;
59157   Dali::FrameBufferImage result;
59158
59159   arg1 = (Dali::Toolkit::Builder *)jarg1;
59160   if (!jarg2) {
59161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59162     return 0;
59163   }
59164   std::string arg2_str(jarg2);
59165   arg2 = &arg2_str;
59166   {
59167     try {
59168       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59169     } catch (std::out_of_range& e) {
59170       {
59171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (std::exception& e) {
59174       {
59175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (...) {
59178       {
59179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59180       };
59181     }
59182   }
59183   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59184
59185   //argout typemap for const std::string&
59186
59187   return jresult;
59188 }
59189
59190
59191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59192   void * jresult ;
59193   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59194   std::string *arg2 = 0 ;
59195   Dali::Path result;
59196
59197   arg1 = (Dali::Toolkit::Builder *)jarg1;
59198   if (!jarg2) {
59199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59200     return 0;
59201   }
59202   std::string arg2_str(jarg2);
59203   arg2 = &arg2_str;
59204   {
59205     try {
59206       result = (arg1)->GetPath((std::string const &)*arg2);
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59214       };
59215     } catch (...) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59218       };
59219     }
59220   }
59221   jresult = new Dali::Path((const Dali::Path &)result);
59222
59223   //argout typemap for const std::string&
59224
59225   return jresult;
59226 }
59227
59228
59229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59230   void * jresult ;
59231   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59232   std::string *arg2 = 0 ;
59233   Dali::PathConstrainer result;
59234
59235   arg1 = (Dali::Toolkit::Builder *)jarg1;
59236   if (!jarg2) {
59237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59238     return 0;
59239   }
59240   std::string arg2_str(jarg2);
59241   arg2 = &arg2_str;
59242   {
59243     try {
59244       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59245     } catch (std::out_of_range& e) {
59246       {
59247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59248       };
59249     } catch (std::exception& e) {
59250       {
59251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59256       };
59257     }
59258   }
59259   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59260
59261   //argout typemap for const std::string&
59262
59263   return jresult;
59264 }
59265
59266
59267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59268   void * jresult ;
59269   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59270   std::string *arg2 = 0 ;
59271   Dali::LinearConstrainer result;
59272
59273   arg1 = (Dali::Toolkit::Builder *)jarg1;
59274   if (!jarg2) {
59275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59276     return 0;
59277   }
59278   std::string arg2_str(jarg2);
59279   arg2 = &arg2_str;
59280   {
59281     try {
59282       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59283     } catch (std::out_of_range& e) {
59284       {
59285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (std::exception& e) {
59288       {
59289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59290       };
59291     } catch (...) {
59292       {
59293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59294       };
59295     }
59296   }
59297   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59298
59299   //argout typemap for const std::string&
59300
59301   return jresult;
59302 }
59303
59304
59305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59306   void * jresult ;
59307   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59308   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59309
59310   arg1 = (Dali::Toolkit::Builder *)jarg1;
59311   {
59312     try {
59313       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59314     } catch (std::out_of_range& e) {
59315       {
59316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59317       };
59318     } catch (std::exception& e) {
59319       {
59320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59321       };
59322     } catch (...) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59325       };
59326     }
59327   }
59328   jresult = (void *)result;
59329   return jresult;
59330 }
59331
59332
59333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59334   void * jresult ;
59335   Dali::Toolkit::TransitionData *result = 0 ;
59336
59337   {
59338     try {
59339       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59340     } catch (std::out_of_range& e) {
59341       {
59342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (std::exception& e) {
59345       {
59346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59347       };
59348     } catch (...) {
59349       {
59350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59351       };
59352     }
59353   }
59354   jresult = (void *)result;
59355   return jresult;
59356 }
59357
59358
59359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59360   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59361
59362   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59363   {
59364     try {
59365       delete arg1;
59366     } catch (std::out_of_range& e) {
59367       {
59368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59369       };
59370     } catch (std::exception& e) {
59371       {
59372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59373       };
59374     } catch (...) {
59375       {
59376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59377       };
59378     }
59379   }
59380 }
59381
59382
59383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59384   void * jresult ;
59385   Dali::Property::Map *arg1 = 0 ;
59386   Dali::Toolkit::TransitionData result;
59387
59388   arg1 = (Dali::Property::Map *)jarg1;
59389   if (!arg1) {
59390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59391     return 0;
59392   }
59393   {
59394     try {
59395       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59396     } catch (std::out_of_range& e) {
59397       {
59398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59399       };
59400     } catch (std::exception& e) {
59401       {
59402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59403       };
59404     } catch (...) {
59405       {
59406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59407       };
59408     }
59409   }
59410   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59411   return jresult;
59412 }
59413
59414
59415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59416   void * jresult ;
59417   Dali::Property::Array *arg1 = 0 ;
59418   Dali::Toolkit::TransitionData result;
59419
59420   arg1 = (Dali::Property::Array *)jarg1;
59421   if (!arg1) {
59422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59423     return 0;
59424   }
59425   {
59426     try {
59427       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59428     } catch (std::out_of_range& e) {
59429       {
59430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59431       };
59432     } catch (std::exception& e) {
59433       {
59434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59435       };
59436     } catch (...) {
59437       {
59438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59439       };
59440     }
59441   }
59442   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59443   return jresult;
59444 }
59445
59446
59447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59448   void * jresult ;
59449   Dali::BaseHandle arg1 ;
59450   Dali::BaseHandle *argp1 ;
59451   Dali::Toolkit::TransitionData result;
59452
59453   argp1 = (Dali::BaseHandle *)jarg1;
59454   if (!argp1) {
59455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59456     return 0;
59457   }
59458   arg1 = *argp1;
59459   {
59460     try {
59461       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59462     } catch (std::out_of_range& e) {
59463       {
59464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59465       };
59466     } catch (std::exception& e) {
59467       {
59468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (...) {
59471       {
59472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59473       };
59474     }
59475   }
59476   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59477   return jresult;
59478 }
59479
59480
59481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59482   void * jresult ;
59483   Dali::Toolkit::TransitionData *arg1 = 0 ;
59484   Dali::Toolkit::TransitionData *result = 0 ;
59485
59486   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59487   if (!arg1) {
59488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59489     return 0;
59490   }
59491   {
59492     try {
59493       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59494     } catch (std::out_of_range& e) {
59495       {
59496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59497       };
59498     } catch (std::exception& e) {
59499       {
59500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59501       };
59502     } catch (...) {
59503       {
59504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59505       };
59506     }
59507   }
59508   jresult = (void *)result;
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59514   void * jresult ;
59515   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59516   Dali::Toolkit::TransitionData *arg2 = 0 ;
59517   Dali::Toolkit::TransitionData *result = 0 ;
59518
59519   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59520   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59521   if (!arg2) {
59522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59523     return 0;
59524   }
59525   {
59526     try {
59527       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (...) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59539       };
59540     }
59541   }
59542   jresult = (void *)result;
59543   return jresult;
59544 }
59545
59546
59547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59548   unsigned long jresult ;
59549   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59550   size_t result;
59551
59552   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59553   {
59554     try {
59555       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59556     } catch (std::out_of_range& e) {
59557       {
59558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59559       };
59560     } catch (std::exception& e) {
59561       {
59562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (...) {
59565       {
59566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59567       };
59568     }
59569   }
59570   jresult = (unsigned long)result;
59571   return jresult;
59572 }
59573
59574
59575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59576   void * jresult ;
59577   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59578   size_t arg2 ;
59579   Dali::Property::Map result;
59580
59581   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59582   arg2 = (size_t)jarg2;
59583   {
59584     try {
59585       result = (arg1)->GetAnimatorAt(arg2);
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (...) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59597       };
59598     }
59599   }
59600   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59601   return jresult;
59602 }
59603
59604
59605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59606   void * jresult ;
59607   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59608   Dali::Toolkit::TransitionData *result = 0 ;
59609
59610   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59611   {
59612     try {
59613       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59614     } catch (std::out_of_range& e) {
59615       {
59616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59617       };
59618     } catch (std::exception& e) {
59619       {
59620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59621       };
59622     } catch (...) {
59623       {
59624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59625       };
59626     }
59627   }
59628   jresult = (void *)result;
59629   return jresult;
59630 }
59631
59632
59633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59634   int jresult ;
59635   int result;
59636
59637   {
59638     try {
59639       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59640     } catch (std::out_of_range& e) {
59641       {
59642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (std::exception& e) {
59645       {
59646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (...) {
59649       {
59650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59651       };
59652     }
59653   }
59654   jresult = (int)result;
59655   return jresult;
59656 }
59657
59658
59659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59660   int jresult ;
59661   int result;
59662
59663   {
59664     try {
59665       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59666     } catch (std::out_of_range& e) {
59667       {
59668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (std::exception& e) {
59671       {
59672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59673       };
59674     } catch (...) {
59675       {
59676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59677       };
59678     }
59679   }
59680   jresult = (int)result;
59681   return jresult;
59682 }
59683
59684
59685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59686   int jresult ;
59687   int result;
59688
59689   {
59690     try {
59691       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59692     } catch (std::out_of_range& e) {
59693       {
59694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (std::exception& e) {
59697       {
59698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (...) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59703       };
59704     }
59705   }
59706   jresult = (int)result;
59707   return jresult;
59708 }
59709
59710
59711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59712   int jresult ;
59713   int result;
59714
59715   {
59716     try {
59717       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59718     } catch (std::out_of_range& e) {
59719       {
59720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59721       };
59722     } catch (std::exception& e) {
59723       {
59724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59725       };
59726     } catch (...) {
59727       {
59728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59729       };
59730     }
59731   }
59732   jresult = (int)result;
59733   return jresult;
59734 }
59735
59736
59737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59738   int jresult ;
59739   int result;
59740
59741   {
59742     try {
59743       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59744     } catch (std::out_of_range& e) {
59745       {
59746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (std::exception& e) {
59749       {
59750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59751       };
59752     } catch (...) {
59753       {
59754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59755       };
59756     }
59757   }
59758   jresult = (int)result;
59759   return jresult;
59760 }
59761
59762
59763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59764   int jresult ;
59765   int result;
59766
59767   {
59768     try {
59769       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59770     } catch (std::out_of_range& e) {
59771       {
59772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59773       };
59774     } catch (std::exception& e) {
59775       {
59776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (...) {
59779       {
59780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59781       };
59782     }
59783   }
59784   jresult = (int)result;
59785   return jresult;
59786 }
59787
59788
59789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59790   int jresult ;
59791   int result;
59792
59793   {
59794     try {
59795       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59796     } catch (std::out_of_range& e) {
59797       {
59798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (std::exception& e) {
59801       {
59802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59803       };
59804     } catch (...) {
59805       {
59806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59807       };
59808     }
59809   }
59810   jresult = (int)result;
59811   return jresult;
59812 }
59813
59814
59815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59816   int jresult ;
59817   int result;
59818
59819   {
59820     try {
59821       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59822     } catch (std::out_of_range& e) {
59823       {
59824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (std::exception& e) {
59827       {
59828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59829       };
59830     } catch (...) {
59831       {
59832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59833       };
59834     }
59835   }
59836   jresult = (int)result;
59837   return jresult;
59838 }
59839
59840
59841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59842   int jresult ;
59843   int result;
59844
59845   {
59846     try {
59847       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59848     } catch (std::out_of_range& e) {
59849       {
59850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (std::exception& e) {
59853       {
59854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59855       };
59856     } catch (...) {
59857       {
59858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59859       };
59860     }
59861   }
59862   jresult = (int)result;
59863   return jresult;
59864 }
59865
59866
59867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59868   int jresult ;
59869   int result;
59870
59871   {
59872     try {
59873       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59874     } catch (std::out_of_range& e) {
59875       {
59876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59877       };
59878     } catch (std::exception& e) {
59879       {
59880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59881       };
59882     } catch (...) {
59883       {
59884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59885       };
59886     }
59887   }
59888   jresult = (int)result;
59889   return jresult;
59890 }
59891
59892
59893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59894   int jresult ;
59895   int result;
59896
59897   {
59898     try {
59899       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59900     } catch (std::out_of_range& e) {
59901       {
59902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59903       };
59904     } catch (std::exception& e) {
59905       {
59906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59907       };
59908     } catch (...) {
59909       {
59910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59911       };
59912     }
59913   }
59914   jresult = (int)result;
59915   return jresult;
59916 }
59917
59918
59919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59920   int jresult ;
59921   int result;
59922
59923   {
59924     try {
59925       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59933       };
59934     } catch (...) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59937       };
59938     }
59939   }
59940   jresult = (int)result;
59941   return jresult;
59942 }
59943
59944
59945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59946   int jresult ;
59947   int result;
59948
59949   {
59950     try {
59951       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59963       };
59964     }
59965   }
59966   jresult = (int)result;
59967   return jresult;
59968 }
59969
59970
59971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59972   int jresult ;
59973   int result;
59974
59975   {
59976     try {
59977       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59978     } catch (std::out_of_range& e) {
59979       {
59980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (std::exception& e) {
59983       {
59984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59985       };
59986     } catch (...) {
59987       {
59988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59989       };
59990     }
59991   }
59992   jresult = (int)result;
59993   return jresult;
59994 }
59995
59996
59997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59998   void * jresult ;
59999   Dali::Toolkit::Control result;
60000
60001   {
60002     try {
60003       result = Dali::Toolkit::Internal::Control::New();
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 = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60019   return jresult;
60020 }
60021
60022
60023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60025   std::string *arg2 = 0 ;
60026
60027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60028   if (!jarg2) {
60029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60030     return ;
60031   }
60032   std::string arg2_str(jarg2);
60033   arg2 = &arg2_str;
60034   {
60035     try {
60036       (arg1)->SetStyleName((std::string const &)*arg2);
60037     } catch (std::out_of_range& e) {
60038       {
60039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60040       };
60041     } catch (std::exception& e) {
60042       {
60043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60044       };
60045     } catch (...) {
60046       {
60047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60048       };
60049     }
60050   }
60051
60052   //argout typemap for const std::string&
60053
60054 }
60055
60056
60057 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60058   char * jresult ;
60059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60060   std::string *result = 0 ;
60061
60062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60063   {
60064     try {
60065       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60066     } catch (std::out_of_range& e) {
60067       {
60068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (std::exception& e) {
60071       {
60072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60073       };
60074     } catch (...) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60077       };
60078     }
60079   }
60080   jresult = SWIG_csharp_string_callback(result->c_str());
60081   return jresult;
60082 }
60083
60084
60085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60087   Dali::Vector4 *arg2 = 0 ;
60088
60089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60090   arg2 = (Dali::Vector4 *)jarg2;
60091   if (!arg2) {
60092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60093     return ;
60094   }
60095   {
60096     try {
60097       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60098     } catch (std::out_of_range& e) {
60099       {
60100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60101       };
60102     } catch (std::exception& e) {
60103       {
60104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60105       };
60106     } catch (...) {
60107       {
60108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60109       };
60110     }
60111   }
60112 }
60113
60114
60115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60116   void * jresult ;
60117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60118   Dali::Vector4 result;
60119
60120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60121   {
60122     try {
60123       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (...) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60135       };
60136     }
60137   }
60138   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60139   return jresult;
60140 }
60141
60142
60143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60145   Dali::Image arg2 ;
60146   Dali::Image *argp2 ;
60147
60148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60149   argp2 = (Dali::Image *)jarg2;
60150   if (!argp2) {
60151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60152     return ;
60153   }
60154   arg2 = *argp2;
60155   {
60156     try {
60157       (arg1)->SetBackgroundImage(arg2);
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60169       };
60170     }
60171   }
60172 }
60173
60174
60175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60177   Dali::Property::Map *arg2 = 0 ;
60178
60179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60180   arg2 = (Dali::Property::Map *)jarg2;
60181   if (!arg2) {
60182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60183     return ;
60184   }
60185   {
60186     try {
60187       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60188     } catch (std::out_of_range& e) {
60189       {
60190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60191       };
60192     } catch (std::exception& e) {
60193       {
60194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60195       };
60196     } catch (...) {
60197       {
60198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60199       };
60200     }
60201   }
60202 }
60203
60204
60205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60207
60208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60209   {
60210     try {
60211       (arg1)->ClearBackground();
60212     } catch (std::out_of_range& e) {
60213       {
60214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60215       };
60216     } catch (std::exception& e) {
60217       {
60218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60219       };
60220     } catch (...) {
60221       {
60222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60223       };
60224     }
60225   }
60226 }
60227
60228
60229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60231   Dali::Gesture::Type arg2 ;
60232
60233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60234   arg2 = (Dali::Gesture::Type)jarg2;
60235   {
60236     try {
60237       (arg1)->EnableGestureDetection(arg2);
60238     } catch (std::out_of_range& e) {
60239       {
60240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60241       };
60242     } catch (std::exception& e) {
60243       {
60244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60245       };
60246     } catch (...) {
60247       {
60248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60249       };
60250     }
60251   }
60252 }
60253
60254
60255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60257   Dali::Gesture::Type arg2 ;
60258
60259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60260   arg2 = (Dali::Gesture::Type)jarg2;
60261   {
60262     try {
60263       (arg1)->DisableGestureDetection(arg2);
60264     } catch (std::out_of_range& e) {
60265       {
60266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (std::exception& e) {
60269       {
60270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60271       };
60272     } catch (...) {
60273       {
60274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60275       };
60276     }
60277   }
60278 }
60279
60280
60281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60282   void * jresult ;
60283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60284   Dali::PinchGestureDetector result;
60285
60286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60287   {
60288     try {
60289       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60290     } catch (std::out_of_range& e) {
60291       {
60292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60293       };
60294     } catch (std::exception& e) {
60295       {
60296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60297       };
60298     } catch (...) {
60299       {
60300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60301       };
60302     }
60303   }
60304   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60305   return jresult;
60306 }
60307
60308
60309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60310   void * jresult ;
60311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60312   Dali::PanGestureDetector result;
60313
60314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60315   {
60316     try {
60317       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60318     } catch (std::out_of_range& e) {
60319       {
60320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (std::exception& e) {
60323       {
60324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (...) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60329       };
60330     }
60331   }
60332   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60333   return jresult;
60334 }
60335
60336
60337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60338   void * jresult ;
60339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60340   Dali::TapGestureDetector result;
60341
60342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60343   {
60344     try {
60345       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60346     } catch (std::out_of_range& e) {
60347       {
60348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60349       };
60350     } catch (std::exception& e) {
60351       {
60352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60353       };
60354     } catch (...) {
60355       {
60356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60357       };
60358     }
60359   }
60360   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60361   return jresult;
60362 }
60363
60364
60365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60366   void * jresult ;
60367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60368   Dali::LongPressGestureDetector result;
60369
60370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60371   {
60372     try {
60373       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60374     } catch (std::out_of_range& e) {
60375       {
60376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60377       };
60378     } catch (std::exception& e) {
60379       {
60380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60385       };
60386     }
60387   }
60388   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60395   bool arg2 ;
60396
60397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60398   arg2 = jarg2 ? true : false;
60399   {
60400     try {
60401       (arg1)->SetKeyboardNavigationSupport(arg2);
60402     } catch (std::out_of_range& e) {
60403       {
60404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60405       };
60406     } catch (std::exception& e) {
60407       {
60408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60409       };
60410     } catch (...) {
60411       {
60412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60413       };
60414     }
60415   }
60416 }
60417
60418
60419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60420   unsigned int jresult ;
60421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60422   bool result;
60423
60424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60425   {
60426     try {
60427       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60428     } catch (std::out_of_range& e) {
60429       {
60430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60431       };
60432     } catch (std::exception& e) {
60433       {
60434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60435       };
60436     } catch (...) {
60437       {
60438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60439       };
60440     }
60441   }
60442   jresult = result;
60443   return jresult;
60444 }
60445
60446
60447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60449
60450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60451   {
60452     try {
60453       (arg1)->SetKeyInputFocus();
60454     } catch (std::out_of_range& e) {
60455       {
60456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60457       };
60458     } catch (std::exception& e) {
60459       {
60460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60461       };
60462     } catch (...) {
60463       {
60464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60465       };
60466     }
60467   }
60468 }
60469
60470
60471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60472   unsigned int jresult ;
60473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60474   bool result;
60475
60476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60477   {
60478     try {
60479       result = (bool)(arg1)->HasKeyInputFocus();
60480     } catch (std::out_of_range& e) {
60481       {
60482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60483       };
60484     } catch (std::exception& e) {
60485       {
60486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60487       };
60488     } catch (...) {
60489       {
60490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60491       };
60492     }
60493   }
60494   jresult = result;
60495   return jresult;
60496 }
60497
60498
60499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60501
60502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60503   {
60504     try {
60505       (arg1)->ClearKeyInputFocus();
60506     } catch (std::out_of_range& e) {
60507       {
60508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60509       };
60510     } catch (std::exception& e) {
60511       {
60512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60513       };
60514     } catch (...) {
60515       {
60516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60517       };
60518     }
60519   }
60520 }
60521
60522
60523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60525   bool arg2 ;
60526
60527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60528   arg2 = jarg2 ? true : false;
60529   {
60530     try {
60531       (arg1)->SetAsKeyboardFocusGroup(arg2);
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60539       };
60540     } catch (...) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60543       };
60544     }
60545   }
60546 }
60547
60548
60549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60550   unsigned int jresult ;
60551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60552   bool result;
60553
60554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60555   {
60556     try {
60557       result = (bool)(arg1)->IsKeyboardFocusGroup();
60558     } catch (std::out_of_range& e) {
60559       {
60560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60561       };
60562     } catch (std::exception& e) {
60563       {
60564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (...) {
60567       {
60568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60569       };
60570     }
60571   }
60572   jresult = result;
60573   return jresult;
60574 }
60575
60576
60577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60579
60580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60581   {
60582     try {
60583       (arg1)->AccessibilityActivate();
60584     } catch (std::out_of_range& e) {
60585       {
60586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60587       };
60588     } catch (std::exception& e) {
60589       {
60590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60591       };
60592     } catch (...) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60595       };
60596     }
60597   }
60598 }
60599
60600
60601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60603
60604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60605   {
60606     try {
60607       (arg1)->KeyboardEnter();
60608     } catch (std::out_of_range& e) {
60609       {
60610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60611       };
60612     } catch (std::exception& e) {
60613       {
60614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60615       };
60616     } catch (...) {
60617       {
60618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60619       };
60620     }
60621   }
60622 }
60623
60624
60625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60626   void * jresult ;
60627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60628   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60629
60630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60631   {
60632     try {
60633       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60634     } catch (std::out_of_range& e) {
60635       {
60636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60637       };
60638     } catch (std::exception& e) {
60639       {
60640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (...) {
60643       {
60644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60645       };
60646     }
60647   }
60648   jresult = (void *)result;
60649   return jresult;
60650 }
60651
60652
60653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60654   void * jresult ;
60655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60656   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60657
60658   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60659   {
60660     try {
60661       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60662     } catch (std::out_of_range& e) {
60663       {
60664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60665       };
60666     } catch (std::exception& e) {
60667       {
60668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60669       };
60670     } catch (...) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60673       };
60674     }
60675   }
60676   jresult = (void *)result;
60677   return jresult;
60678 }
60679
60680
60681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60682   void * jresult ;
60683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60684   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60685
60686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60687   {
60688     try {
60689       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704   jresult = (void *)result;
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60710   unsigned int jresult ;
60711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60712   Dali::KeyEvent *arg2 = 0 ;
60713   bool result;
60714
60715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60716   arg2 = (Dali::KeyEvent *)jarg2;
60717   if (!arg2) {
60718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60719     return 0;
60720   }
60721   {
60722     try {
60723       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60724     } catch (std::out_of_range& e) {
60725       {
60726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60727       };
60728     } catch (std::exception& e) {
60729       {
60730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (...) {
60733       {
60734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60735       };
60736     }
60737   }
60738   jresult = result;
60739   return jresult;
60740 }
60741
60742
60743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60745   int arg2 ;
60746   SwigDirector_ViewImpl *darg = 0;
60747
60748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60749   arg2 = (int)jarg2;
60750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60751   {
60752     try {
60753       (darg)->OnStageConnection(arg2);
60754     } catch (std::out_of_range& e) {
60755       {
60756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60757       };
60758     } catch (std::exception& e) {
60759       {
60760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60761       };
60762     } catch (...) {
60763       {
60764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60765       };
60766     }
60767   }
60768 }
60769
60770
60771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60773   int arg2 ;
60774   SwigDirector_ViewImpl *darg = 0;
60775
60776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60777   arg2 = (int)jarg2;
60778   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60779   {
60780     try {
60781       (darg)->OnStageConnectionSwigPublic(arg2);
60782     } catch (std::out_of_range& e) {
60783       {
60784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60785       };
60786     } catch (std::exception& e) {
60787       {
60788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60789       };
60790     } catch (...) {
60791       {
60792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60793       };
60794     }
60795   }
60796 }
60797
60798
60799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60801   SwigDirector_ViewImpl *darg = 0;
60802
60803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60804   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60805   {
60806     try {
60807       (darg)->OnStageDisconnection();
60808     } catch (std::out_of_range& e) {
60809       {
60810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (std::exception& e) {
60813       {
60814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60815       };
60816     } catch (...) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60819       };
60820     }
60821   }
60822 }
60823
60824
60825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60826   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60827   SwigDirector_ViewImpl *darg = 0;
60828
60829   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60830   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60831   {
60832     try {
60833       (darg)->OnStageDisconnectionSwigPublic();
60834     } catch (std::out_of_range& e) {
60835       {
60836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60837       };
60838     } catch (std::exception& e) {
60839       {
60840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60841       };
60842     } catch (...) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60845       };
60846     }
60847   }
60848 }
60849
60850
60851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60853   Dali::Actor *arg2 = 0 ;
60854   SwigDirector_ViewImpl *darg = 0;
60855
60856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60857   arg2 = (Dali::Actor *)jarg2;
60858   if (!arg2) {
60859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60860     return ;
60861   }
60862   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60863   {
60864     try {
60865       (darg)->OnChildAdd(*arg2);
60866     } catch (std::out_of_range& e) {
60867       {
60868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60869       };
60870     } catch (std::exception& e) {
60871       {
60872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60873       };
60874     } catch (...) {
60875       {
60876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60877       };
60878     }
60879   }
60880 }
60881
60882
60883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60884   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60885   Dali::Actor *arg2 = 0 ;
60886   SwigDirector_ViewImpl *darg = 0;
60887
60888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60889   arg2 = (Dali::Actor *)jarg2;
60890   if (!arg2) {
60891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60892     return ;
60893   }
60894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60895   {
60896     try {
60897       (darg)->OnChildAddSwigPublic(*arg2);
60898     } catch (std::out_of_range& e) {
60899       {
60900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60901       };
60902     } catch (std::exception& e) {
60903       {
60904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60905       };
60906     } catch (...) {
60907       {
60908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60909       };
60910     }
60911   }
60912 }
60913
60914
60915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60917   Dali::Actor *arg2 = 0 ;
60918   SwigDirector_ViewImpl *darg = 0;
60919
60920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60921   arg2 = (Dali::Actor *)jarg2;
60922   if (!arg2) {
60923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60924     return ;
60925   }
60926   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60927   {
60928     try {
60929       (darg)->OnChildRemove(*arg2);
60930     } catch (std::out_of_range& e) {
60931       {
60932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60933       };
60934     } catch (std::exception& e) {
60935       {
60936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60941       };
60942     }
60943   }
60944 }
60945
60946
60947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60949   Dali::Actor *arg2 = 0 ;
60950   SwigDirector_ViewImpl *darg = 0;
60951
60952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60953   arg2 = (Dali::Actor *)jarg2;
60954   if (!arg2) {
60955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60956     return ;
60957   }
60958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60959   {
60960     try {
60961       (darg)->OnChildRemoveSwigPublic(*arg2);
60962     } catch (std::out_of_range& e) {
60963       {
60964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60965       };
60966     } catch (std::exception& e) {
60967       {
60968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60973       };
60974     }
60975   }
60976 }
60977
60978
60979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60981   Dali::Property::Index arg2 ;
60982   Dali::Property::Value arg3 ;
60983   Dali::Property::Value *argp3 ;
60984   SwigDirector_ViewImpl *darg = 0;
60985
60986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60987   arg2 = (Dali::Property::Index)jarg2;
60988   argp3 = (Dali::Property::Value *)jarg3;
60989   if (!argp3) {
60990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60991     return ;
60992   }
60993   arg3 = *argp3;
60994   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60995   {
60996     try {
60997       (darg)->OnPropertySet(arg2,arg3);
60998     } catch (std::out_of_range& e) {
60999       {
61000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61001       };
61002     } catch (std::exception& e) {
61003       {
61004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61005       };
61006     } catch (...) {
61007       {
61008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61009       };
61010     }
61011   }
61012 }
61013
61014
61015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61017   Dali::Property::Index arg2 ;
61018   Dali::Property::Value arg3 ;
61019   Dali::Property::Value *argp3 ;
61020   SwigDirector_ViewImpl *darg = 0;
61021
61022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61023   arg2 = (Dali::Property::Index)jarg2;
61024   argp3 = (Dali::Property::Value *)jarg3;
61025   if (!argp3) {
61026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61027     return ;
61028   }
61029   arg3 = *argp3;
61030   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61031   {
61032     try {
61033       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61034     } catch (std::out_of_range& e) {
61035       {
61036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61037       };
61038     } catch (std::exception& e) {
61039       {
61040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61041       };
61042     } catch (...) {
61043       {
61044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61045       };
61046     }
61047   }
61048 }
61049
61050
61051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61053   Dali::Vector3 *arg2 = 0 ;
61054   SwigDirector_ViewImpl *darg = 0;
61055
61056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61057   arg2 = (Dali::Vector3 *)jarg2;
61058   if (!arg2) {
61059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61060     return ;
61061   }
61062   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61063   {
61064     try {
61065       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61066     } catch (std::out_of_range& e) {
61067       {
61068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61069       };
61070     } catch (std::exception& e) {
61071       {
61072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61073       };
61074     } catch (...) {
61075       {
61076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61077       };
61078     }
61079   }
61080 }
61081
61082
61083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61085   Dali::Vector3 *arg2 = 0 ;
61086   SwigDirector_ViewImpl *darg = 0;
61087
61088   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61089   arg2 = (Dali::Vector3 *)jarg2;
61090   if (!arg2) {
61091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61092     return ;
61093   }
61094   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61095   {
61096     try {
61097       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61098     } catch (std::out_of_range& e) {
61099       {
61100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61101       };
61102     } catch (std::exception& e) {
61103       {
61104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61105       };
61106     } catch (...) {
61107       {
61108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61109       };
61110     }
61111   }
61112 }
61113
61114
61115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61117   Dali::Animation *arg2 = 0 ;
61118   Dali::Vector3 *arg3 = 0 ;
61119   SwigDirector_ViewImpl *darg = 0;
61120
61121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61122   arg2 = (Dali::Animation *)jarg2;
61123   if (!arg2) {
61124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61125     return ;
61126   }
61127   arg3 = (Dali::Vector3 *)jarg3;
61128   if (!arg3) {
61129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61130     return ;
61131   }
61132   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61133   {
61134     try {
61135       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61136     } catch (std::out_of_range& e) {
61137       {
61138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61139       };
61140     } catch (std::exception& e) {
61141       {
61142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61143       };
61144     } catch (...) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61147       };
61148     }
61149   }
61150 }
61151
61152
61153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61155   Dali::Animation *arg2 = 0 ;
61156   Dali::Vector3 *arg3 = 0 ;
61157   SwigDirector_ViewImpl *darg = 0;
61158
61159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61160   arg2 = (Dali::Animation *)jarg2;
61161   if (!arg2) {
61162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61163     return ;
61164   }
61165   arg3 = (Dali::Vector3 *)jarg3;
61166   if (!arg3) {
61167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61168     return ;
61169   }
61170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61171   {
61172     try {
61173       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61181       };
61182     } catch (...) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61185       };
61186     }
61187   }
61188 }
61189
61190
61191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61192   unsigned int jresult ;
61193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61194   Dali::TouchEvent *arg2 = 0 ;
61195   SwigDirector_ViewImpl *darg = 0;
61196   bool result;
61197
61198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61199   arg2 = (Dali::TouchEvent *)jarg2;
61200   if (!arg2) {
61201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61202     return 0;
61203   }
61204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61205   {
61206     try {
61207       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61208     } catch (std::out_of_range& e) {
61209       {
61210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61211       };
61212     } catch (std::exception& e) {
61213       {
61214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (...) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61219       };
61220     }
61221   }
61222   jresult = result;
61223   return jresult;
61224 }
61225
61226
61227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61228   unsigned int jresult ;
61229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61230   Dali::TouchEvent *arg2 = 0 ;
61231   SwigDirector_ViewImpl *darg = 0;
61232   bool result;
61233
61234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61235   arg2 = (Dali::TouchEvent *)jarg2;
61236   if (!arg2) {
61237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61238     return 0;
61239   }
61240   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61241   {
61242     try {
61243       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61244     } catch (std::out_of_range& e) {
61245       {
61246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61247       };
61248     } catch (std::exception& e) {
61249       {
61250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61251       };
61252     } catch (...) {
61253       {
61254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61255       };
61256     }
61257   }
61258   jresult = result;
61259   return jresult;
61260 }
61261
61262
61263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61264   unsigned int jresult ;
61265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61266   Dali::HoverEvent *arg2 = 0 ;
61267   SwigDirector_ViewImpl *darg = 0;
61268   bool result;
61269
61270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61271   arg2 = (Dali::HoverEvent *)jarg2;
61272   if (!arg2) {
61273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61274     return 0;
61275   }
61276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61277   {
61278     try {
61279       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61280     } catch (std::out_of_range& e) {
61281       {
61282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61283       };
61284     } catch (std::exception& e) {
61285       {
61286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (...) {
61289       {
61290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61291       };
61292     }
61293   }
61294   jresult = result;
61295   return jresult;
61296 }
61297
61298
61299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61300   unsigned int jresult ;
61301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61302   Dali::HoverEvent *arg2 = 0 ;
61303   SwigDirector_ViewImpl *darg = 0;
61304   bool result;
61305
61306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61307   arg2 = (Dali::HoverEvent *)jarg2;
61308   if (!arg2) {
61309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61310     return 0;
61311   }
61312   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61313   {
61314     try {
61315       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61316     } catch (std::out_of_range& e) {
61317       {
61318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61319       };
61320     } catch (std::exception& e) {
61321       {
61322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61323       };
61324     } catch (...) {
61325       {
61326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61327       };
61328     }
61329   }
61330   jresult = result;
61331   return jresult;
61332 }
61333
61334
61335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61336   unsigned int jresult ;
61337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61338   Dali::KeyEvent *arg2 = 0 ;
61339   SwigDirector_ViewImpl *darg = 0;
61340   bool result;
61341
61342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61343   arg2 = (Dali::KeyEvent *)jarg2;
61344   if (!arg2) {
61345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61346     return 0;
61347   }
61348   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61349   {
61350     try {
61351       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61352     } catch (std::out_of_range& e) {
61353       {
61354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61355       };
61356     } catch (std::exception& e) {
61357       {
61358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61359       };
61360     } catch (...) {
61361       {
61362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61363       };
61364     }
61365   }
61366   jresult = result;
61367   return jresult;
61368 }
61369
61370
61371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61372   unsigned int jresult ;
61373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61374   Dali::KeyEvent *arg2 = 0 ;
61375   SwigDirector_ViewImpl *darg = 0;
61376   bool result;
61377
61378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61379   arg2 = (Dali::KeyEvent *)jarg2;
61380   if (!arg2) {
61381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61382     return 0;
61383   }
61384   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61385   {
61386     try {
61387       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61388     } catch (std::out_of_range& e) {
61389       {
61390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61391       };
61392     } catch (std::exception& e) {
61393       {
61394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61399       };
61400     }
61401   }
61402   jresult = result;
61403   return jresult;
61404 }
61405
61406
61407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61408   unsigned int jresult ;
61409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61410   Dali::WheelEvent *arg2 = 0 ;
61411   SwigDirector_ViewImpl *darg = 0;
61412   bool result;
61413
61414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61415   arg2 = (Dali::WheelEvent *)jarg2;
61416   if (!arg2) {
61417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61418     return 0;
61419   }
61420   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61421   {
61422     try {
61423       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61424     } catch (std::out_of_range& e) {
61425       {
61426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61427       };
61428     } catch (std::exception& e) {
61429       {
61430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61431       };
61432     } catch (...) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61435       };
61436     }
61437   }
61438   jresult = result;
61439   return jresult;
61440 }
61441
61442
61443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61444   unsigned int jresult ;
61445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61446   Dali::WheelEvent *arg2 = 0 ;
61447   SwigDirector_ViewImpl *darg = 0;
61448   bool result;
61449
61450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61451   arg2 = (Dali::WheelEvent *)jarg2;
61452   if (!arg2) {
61453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61454     return 0;
61455   }
61456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61457   {
61458     try {
61459       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61460     } catch (std::out_of_range& e) {
61461       {
61462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61463       };
61464     } catch (std::exception& e) {
61465       {
61466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (...) {
61469       {
61470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61471       };
61472     }
61473   }
61474   jresult = result;
61475   return jresult;
61476 }
61477
61478
61479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61481   Dali::Vector2 *arg2 = 0 ;
61482   Dali::RelayoutContainer *arg3 = 0 ;
61483   SwigDirector_ViewImpl *darg = 0;
61484
61485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61486   arg2 = (Dali::Vector2 *)jarg2;
61487   if (!arg2) {
61488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61489     return ;
61490   }
61491   arg3 = (Dali::RelayoutContainer *)jarg3;
61492   if (!arg3) {
61493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61494     return ;
61495   }
61496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61497   {
61498     try {
61499       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61500     } catch (std::out_of_range& e) {
61501       {
61502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61503       };
61504     } catch (std::exception& e) {
61505       {
61506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61507       };
61508     } catch (...) {
61509       {
61510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61511       };
61512     }
61513   }
61514 }
61515
61516
61517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61519   Dali::Vector2 *arg2 = 0 ;
61520   Dali::RelayoutContainer *arg3 = 0 ;
61521   SwigDirector_ViewImpl *darg = 0;
61522
61523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61524   arg2 = (Dali::Vector2 *)jarg2;
61525   if (!arg2) {
61526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61527     return ;
61528   }
61529   arg3 = (Dali::RelayoutContainer *)jarg3;
61530   if (!arg3) {
61531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61532     return ;
61533   }
61534   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61535   {
61536     try {
61537       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61538     } catch (std::out_of_range& e) {
61539       {
61540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61541       };
61542     } catch (std::exception& e) {
61543       {
61544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61545       };
61546     } catch (...) {
61547       {
61548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61549       };
61550     }
61551   }
61552 }
61553
61554
61555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61557   Dali::ResizePolicy::Type arg2 ;
61558   Dali::Dimension::Type arg3 ;
61559   SwigDirector_ViewImpl *darg = 0;
61560
61561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61562   arg2 = (Dali::ResizePolicy::Type)jarg2;
61563   arg3 = (Dali::Dimension::Type)jarg3;
61564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61565   {
61566     try {
61567       (darg)->OnSetResizePolicy(arg2,arg3);
61568     } catch (std::out_of_range& e) {
61569       {
61570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61571       };
61572     } catch (std::exception& e) {
61573       {
61574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61575       };
61576     } catch (...) {
61577       {
61578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61579       };
61580     }
61581   }
61582 }
61583
61584
61585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61587   Dali::ResizePolicy::Type arg2 ;
61588   Dali::Dimension::Type arg3 ;
61589   SwigDirector_ViewImpl *darg = 0;
61590
61591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61592   arg2 = (Dali::ResizePolicy::Type)jarg2;
61593   arg3 = (Dali::Dimension::Type)jarg3;
61594   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61595   {
61596     try {
61597       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61598     } catch (std::out_of_range& e) {
61599       {
61600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61601       };
61602     } catch (std::exception& e) {
61603       {
61604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61605       };
61606     } catch (...) {
61607       {
61608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61609       };
61610     }
61611   }
61612 }
61613
61614
61615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61616   void * jresult ;
61617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61618   SwigDirector_ViewImpl *darg = 0;
61619   Dali::Vector3 result;
61620
61621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61622   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61623   {
61624     try {
61625       result = (darg)->GetNaturalSize();
61626     } catch (std::out_of_range& e) {
61627       {
61628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61629       };
61630     } catch (std::exception& e) {
61631       {
61632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61633       };
61634     } catch (...) {
61635       {
61636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61637       };
61638     }
61639   }
61640   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61641   return jresult;
61642 }
61643
61644
61645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61646   void * jresult ;
61647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61648   SwigDirector_ViewImpl *darg = 0;
61649   Dali::Vector3 result;
61650
61651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61653   {
61654     try {
61655       result = (darg)->GetNaturalSizeSwigPublic();
61656     } catch (std::out_of_range& e) {
61657       {
61658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61659       };
61660     } catch (std::exception& e) {
61661       {
61662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61663       };
61664     } catch (...) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61667       };
61668     }
61669   }
61670   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61671   return jresult;
61672 }
61673
61674
61675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61676   float jresult ;
61677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61678   Dali::Actor *arg2 = 0 ;
61679   Dali::Dimension::Type arg3 ;
61680   SwigDirector_ViewImpl *darg = 0;
61681   float result;
61682
61683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61684   arg2 = (Dali::Actor *)jarg2;
61685   if (!arg2) {
61686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61687     return 0;
61688   }
61689   arg3 = (Dali::Dimension::Type)jarg3;
61690   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61691   {
61692     try {
61693       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (...) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61705       };
61706     }
61707   }
61708   jresult = result;
61709   return jresult;
61710 }
61711
61712
61713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61714   float jresult ;
61715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61716   Dali::Actor *arg2 = 0 ;
61717   Dali::Dimension::Type arg3 ;
61718   SwigDirector_ViewImpl *darg = 0;
61719   float result;
61720
61721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61722   arg2 = (Dali::Actor *)jarg2;
61723   if (!arg2) {
61724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61725     return 0;
61726   }
61727   arg3 = (Dali::Dimension::Type)jarg3;
61728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61729   {
61730     try {
61731       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61732     } catch (std::out_of_range& e) {
61733       {
61734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61735       };
61736     } catch (std::exception& e) {
61737       {
61738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61739       };
61740     } catch (...) {
61741       {
61742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61743       };
61744     }
61745   }
61746   jresult = result;
61747   return jresult;
61748 }
61749
61750
61751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61752   float jresult ;
61753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61754   float arg2 ;
61755   SwigDirector_ViewImpl *darg = 0;
61756   float result;
61757
61758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61759   arg2 = (float)jarg2;
61760   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61761   {
61762     try {
61763       result = (float)(darg)->GetHeightForWidth(arg2);
61764     } catch (std::out_of_range& e) {
61765       {
61766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61767       };
61768     } catch (std::exception& e) {
61769       {
61770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61771       };
61772     } catch (...) {
61773       {
61774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61775       };
61776     }
61777   }
61778   jresult = result;
61779   return jresult;
61780 }
61781
61782
61783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61784   float jresult ;
61785   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61786   float arg2 ;
61787   SwigDirector_ViewImpl *darg = 0;
61788   float result;
61789
61790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61791   arg2 = (float)jarg2;
61792   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61793   {
61794     try {
61795       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61796     } catch (std::out_of_range& e) {
61797       {
61798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61799       };
61800     } catch (std::exception& e) {
61801       {
61802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (...) {
61805       {
61806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61807       };
61808     }
61809   }
61810   jresult = result;
61811   return jresult;
61812 }
61813
61814
61815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61816   float jresult ;
61817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61818   float arg2 ;
61819   SwigDirector_ViewImpl *darg = 0;
61820   float result;
61821
61822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61823   arg2 = (float)jarg2;
61824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61825   {
61826     try {
61827       result = (float)(darg)->GetWidthForHeight(arg2);
61828     } catch (std::out_of_range& e) {
61829       {
61830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61831       };
61832     } catch (std::exception& e) {
61833       {
61834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61835       };
61836     } catch (...) {
61837       {
61838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61839       };
61840     }
61841   }
61842   jresult = result;
61843   return jresult;
61844 }
61845
61846
61847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61848   float jresult ;
61849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61850   float arg2 ;
61851   SwigDirector_ViewImpl *darg = 0;
61852   float result;
61853
61854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61855   arg2 = (float)jarg2;
61856   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61857   {
61858     try {
61859       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61860     } catch (std::out_of_range& e) {
61861       {
61862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61863       };
61864     } catch (std::exception& e) {
61865       {
61866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61867       };
61868     } catch (...) {
61869       {
61870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61871       };
61872     }
61873   }
61874   jresult = result;
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61880   unsigned int jresult ;
61881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61882   Dali::Dimension::Type arg2 ;
61883   SwigDirector_ViewImpl *darg = 0;
61884   bool result;
61885
61886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61887   arg2 = (Dali::Dimension::Type)jarg2;
61888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61889   {
61890     try {
61891       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61892     } catch (std::out_of_range& e) {
61893       {
61894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61895       };
61896     } catch (std::exception& e) {
61897       {
61898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61899       };
61900     } catch (...) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61903       };
61904     }
61905   }
61906   jresult = result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61912   unsigned int jresult ;
61913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61914   Dali::Dimension::Type arg2 ;
61915   SwigDirector_ViewImpl *darg = 0;
61916   bool result;
61917
61918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61919   arg2 = (Dali::Dimension::Type)jarg2;
61920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61921   {
61922     try {
61923       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61924     } catch (std::out_of_range& e) {
61925       {
61926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61927       };
61928     } catch (std::exception& e) {
61929       {
61930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61931       };
61932     } catch (...) {
61933       {
61934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61935       };
61936     }
61937   }
61938   jresult = result;
61939   return jresult;
61940 }
61941
61942
61943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61944   unsigned int jresult ;
61945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61946   SwigDirector_ViewImpl *darg = 0;
61947   bool result;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61951   {
61952     try {
61953       result = (bool)(darg)->RelayoutDependentOnChildren();
61954     } catch (std::out_of_range& e) {
61955       {
61956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61957       };
61958     } catch (std::exception& e) {
61959       {
61960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61961       };
61962     } catch (...) {
61963       {
61964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61965       };
61966     }
61967   }
61968   jresult = result;
61969   return jresult;
61970 }
61971
61972
61973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61974   unsigned int jresult ;
61975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61976   SwigDirector_ViewImpl *darg = 0;
61977   bool result;
61978
61979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61981   {
61982     try {
61983       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61984     } catch (std::out_of_range& e) {
61985       {
61986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61987       };
61988     } catch (std::exception& e) {
61989       {
61990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (...) {
61993       {
61994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61995       };
61996     }
61997   }
61998   jresult = result;
61999   return jresult;
62000 }
62001
62002
62003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62004   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62005   Dali::Dimension::Type arg2 ;
62006   SwigDirector_ViewImpl *darg = 0;
62007
62008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62009   arg2 = (Dali::Dimension::Type)jarg2;
62010   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62011   {
62012     try {
62013       (darg)->OnCalculateRelayoutSize(arg2);
62014     } catch (std::out_of_range& e) {
62015       {
62016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62017       };
62018     } catch (std::exception& e) {
62019       {
62020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62021       };
62022     } catch (...) {
62023       {
62024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62025       };
62026     }
62027   }
62028 }
62029
62030
62031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62033   Dali::Dimension::Type arg2 ;
62034   SwigDirector_ViewImpl *darg = 0;
62035
62036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62037   arg2 = (Dali::Dimension::Type)jarg2;
62038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62039   {
62040     try {
62041       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62042     } catch (std::out_of_range& e) {
62043       {
62044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62045       };
62046     } catch (std::exception& e) {
62047       {
62048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62049       };
62050     } catch (...) {
62051       {
62052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62053       };
62054     }
62055   }
62056 }
62057
62058
62059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62061   float arg2 ;
62062   Dali::Dimension::Type arg3 ;
62063   SwigDirector_ViewImpl *darg = 0;
62064
62065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62066   arg2 = (float)jarg2;
62067   arg3 = (Dali::Dimension::Type)jarg3;
62068   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62069   {
62070     try {
62071       (darg)->OnLayoutNegotiated(arg2,arg3);
62072     } catch (std::out_of_range& e) {
62073       {
62074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62075       };
62076     } catch (std::exception& e) {
62077       {
62078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62079       };
62080     } catch (...) {
62081       {
62082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62083       };
62084     }
62085   }
62086 }
62087
62088
62089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62091   float arg2 ;
62092   Dali::Dimension::Type arg3 ;
62093   SwigDirector_ViewImpl *darg = 0;
62094
62095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62096   arg2 = (float)jarg2;
62097   arg3 = (Dali::Dimension::Type)jarg3;
62098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62099   {
62100     try {
62101       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62102     } catch (std::out_of_range& e) {
62103       {
62104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62105       };
62106     } catch (std::exception& e) {
62107       {
62108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (...) {
62111       {
62112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62113       };
62114     }
62115   }
62116 }
62117
62118
62119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62121
62122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62123   {
62124     try {
62125       (arg1)->OnInitialize();
62126     } catch (std::out_of_range& e) {
62127       {
62128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62129       };
62130     } catch (std::exception& e) {
62131       {
62132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62133       };
62134     } catch (...) {
62135       {
62136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62137       };
62138     }
62139   }
62140 }
62141
62142
62143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62145
62146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62147   {
62148     try {
62149       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62150     } catch (std::out_of_range& e) {
62151       {
62152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62153       };
62154     } catch (std::exception& e) {
62155       {
62156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62157       };
62158     } catch (...) {
62159       {
62160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62161       };
62162     }
62163   }
62164 }
62165
62166
62167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62169   Dali::Actor *arg2 = 0 ;
62170
62171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62172   arg2 = (Dali::Actor *)jarg2;
62173   if (!arg2) {
62174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62175     return ;
62176   }
62177   {
62178     try {
62179       (arg1)->OnControlChildAdd(*arg2);
62180     } catch (std::out_of_range& e) {
62181       {
62182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62183       };
62184     } catch (std::exception& e) {
62185       {
62186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62187       };
62188     } catch (...) {
62189       {
62190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62191       };
62192     }
62193   }
62194 }
62195
62196
62197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62199   Dali::Actor *arg2 = 0 ;
62200
62201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62202   arg2 = (Dali::Actor *)jarg2;
62203   if (!arg2) {
62204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62205     return ;
62206   }
62207   {
62208     try {
62209       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62210     } catch (std::out_of_range& e) {
62211       {
62212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62213       };
62214     } catch (std::exception& e) {
62215       {
62216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62217       };
62218     } catch (...) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62221       };
62222     }
62223   }
62224 }
62225
62226
62227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62229   Dali::Actor *arg2 = 0 ;
62230
62231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62232   arg2 = (Dali::Actor *)jarg2;
62233   if (!arg2) {
62234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62235     return ;
62236   }
62237   {
62238     try {
62239       (arg1)->OnControlChildRemove(*arg2);
62240     } catch (std::out_of_range& e) {
62241       {
62242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (std::exception& e) {
62245       {
62246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (...) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62251       };
62252     }
62253   }
62254 }
62255
62256
62257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62259   Dali::Actor *arg2 = 0 ;
62260
62261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62262   arg2 = (Dali::Actor *)jarg2;
62263   if (!arg2) {
62264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62265     return ;
62266   }
62267   {
62268     try {
62269       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62281       };
62282     }
62283   }
62284 }
62285
62286
62287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62289   Dali::Toolkit::StyleManager arg2 ;
62290   Dali::StyleChange::Type arg3 ;
62291   Dali::Toolkit::StyleManager *argp2 ;
62292
62293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62294   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62295   if (!argp2) {
62296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62297     return ;
62298   }
62299   arg2 = *argp2;
62300   arg3 = (Dali::StyleChange::Type)jarg3;
62301   {
62302     try {
62303       (arg1)->OnStyleChange(arg2,arg3);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62315       };
62316     }
62317   }
62318 }
62319
62320
62321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62323   Dali::Toolkit::StyleManager arg2 ;
62324   Dali::StyleChange::Type arg3 ;
62325   Dali::Toolkit::StyleManager *argp2 ;
62326
62327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62328   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62329   if (!argp2) {
62330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62331     return ;
62332   }
62333   arg2 = *argp2;
62334   arg3 = (Dali::StyleChange::Type)jarg3;
62335   {
62336     try {
62337       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62338     } catch (std::out_of_range& e) {
62339       {
62340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (std::exception& e) {
62343       {
62344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62345       };
62346     } catch (...) {
62347       {
62348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62349       };
62350     }
62351   }
62352 }
62353
62354
62355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62356   unsigned int jresult ;
62357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62358   bool result;
62359
62360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62361   {
62362     try {
62363       result = (bool)(arg1)->OnAccessibilityActivated();
62364     } catch (std::out_of_range& e) {
62365       {
62366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62367       };
62368     } catch (std::exception& e) {
62369       {
62370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62371       };
62372     } catch (...) {
62373       {
62374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62375       };
62376     }
62377   }
62378   jresult = result;
62379   return jresult;
62380 }
62381
62382
62383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62384   unsigned int jresult ;
62385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62386   bool result;
62387
62388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62389   {
62390     try {
62391       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406   jresult = result;
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62412   unsigned int jresult ;
62413   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62414   Dali::PanGesture arg2 ;
62415   Dali::PanGesture *argp2 ;
62416   bool result;
62417
62418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62419   argp2 = (Dali::PanGesture *)jarg2;
62420   if (!argp2) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62422     return 0;
62423   }
62424   arg2 = *argp2;
62425   {
62426     try {
62427       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62428     } catch (std::out_of_range& e) {
62429       {
62430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62431       };
62432     } catch (std::exception& e) {
62433       {
62434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62435       };
62436     } catch (...) {
62437       {
62438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62439       };
62440     }
62441   }
62442   jresult = result;
62443   return jresult;
62444 }
62445
62446
62447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62448   unsigned int jresult ;
62449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62450   Dali::PanGesture arg2 ;
62451   Dali::PanGesture *argp2 ;
62452   bool result;
62453
62454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62455   argp2 = (Dali::PanGesture *)jarg2;
62456   if (!argp2) {
62457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62458     return 0;
62459   }
62460   arg2 = *argp2;
62461   {
62462     try {
62463       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62464     } catch (std::out_of_range& e) {
62465       {
62466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62467       };
62468     } catch (std::exception& e) {
62469       {
62470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62471       };
62472     } catch (...) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62475       };
62476     }
62477   }
62478   jresult = result;
62479   return jresult;
62480 }
62481
62482
62483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62484   unsigned int jresult ;
62485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62486   Dali::TouchEvent *arg2 = 0 ;
62487   bool result;
62488
62489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62490   arg2 = (Dali::TouchEvent *)jarg2;
62491   if (!arg2) {
62492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62493     return 0;
62494   }
62495   {
62496     try {
62497       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62498     } catch (std::out_of_range& e) {
62499       {
62500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62501       };
62502     } catch (std::exception& e) {
62503       {
62504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (...) {
62507       {
62508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62509       };
62510     }
62511   }
62512   jresult = result;
62513   return jresult;
62514 }
62515
62516
62517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62518   unsigned int jresult ;
62519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62520   Dali::TouchEvent *arg2 = 0 ;
62521   bool result;
62522
62523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62524   arg2 = (Dali::TouchEvent *)jarg2;
62525   if (!arg2) {
62526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62527     return 0;
62528   }
62529   {
62530     try {
62531       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (...) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62543       };
62544     }
62545   }
62546   jresult = result;
62547   return jresult;
62548 }
62549
62550
62551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62552   unsigned int jresult ;
62553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62554   bool arg2 ;
62555   bool result;
62556
62557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62558   arg2 = jarg2 ? true : false;
62559   {
62560     try {
62561       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62562     } catch (std::out_of_range& e) {
62563       {
62564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62565       };
62566     } catch (std::exception& e) {
62567       {
62568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (...) {
62571       {
62572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62573       };
62574     }
62575   }
62576   jresult = result;
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62582   unsigned int jresult ;
62583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62584   bool arg2 ;
62585   bool result;
62586
62587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62588   arg2 = jarg2 ? true : false;
62589   {
62590     try {
62591       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62592     } catch (std::out_of_range& e) {
62593       {
62594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62595       };
62596     } catch (std::exception& e) {
62597       {
62598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62603       };
62604     }
62605   }
62606   jresult = result;
62607   return jresult;
62608 }
62609
62610
62611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62612   unsigned int jresult ;
62613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62614   bool result;
62615
62616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62617   {
62618     try {
62619       result = (bool)(arg1)->OnAccessibilityZoom();
62620     } catch (std::out_of_range& e) {
62621       {
62622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62623       };
62624     } catch (std::exception& e) {
62625       {
62626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62627       };
62628     } catch (...) {
62629       {
62630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62631       };
62632     }
62633   }
62634   jresult = result;
62635   return jresult;
62636 }
62637
62638
62639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62640   unsigned int jresult ;
62641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62642   bool result;
62643
62644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62645   {
62646     try {
62647       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62648     } catch (std::out_of_range& e) {
62649       {
62650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62651       };
62652     } catch (std::exception& e) {
62653       {
62654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62655       };
62656     } catch (...) {
62657       {
62658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62659       };
62660     }
62661   }
62662   jresult = result;
62663   return jresult;
62664 }
62665
62666
62667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62669
62670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62671   {
62672     try {
62673       (arg1)->OnKeyInputFocusGained();
62674     } catch (std::out_of_range& e) {
62675       {
62676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62677       };
62678     } catch (std::exception& e) {
62679       {
62680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62681       };
62682     } catch (...) {
62683       {
62684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62685       };
62686     }
62687   }
62688 }
62689
62690
62691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62692   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62693
62694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62695   {
62696     try {
62697       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62698     } catch (std::out_of_range& e) {
62699       {
62700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62701       };
62702     } catch (std::exception& e) {
62703       {
62704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62705       };
62706     } catch (...) {
62707       {
62708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62709       };
62710     }
62711   }
62712 }
62713
62714
62715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62717
62718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62719   {
62720     try {
62721       (arg1)->OnKeyInputFocusLost();
62722     } catch (std::out_of_range& e) {
62723       {
62724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62725       };
62726     } catch (std::exception& e) {
62727       {
62728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62733       };
62734     }
62735   }
62736 }
62737
62738
62739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62741
62742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62743   {
62744     try {
62745       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62746     } catch (std::out_of_range& e) {
62747       {
62748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62749       };
62750     } catch (std::exception& e) {
62751       {
62752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62753       };
62754     } catch (...) {
62755       {
62756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62757       };
62758     }
62759   }
62760 }
62761
62762
62763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62764   void * jresult ;
62765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62766   Dali::Actor arg2 ;
62767   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62768   bool arg4 ;
62769   Dali::Actor *argp2 ;
62770   Dali::Actor result;
62771
62772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62773   argp2 = (Dali::Actor *)jarg2;
62774   if (!argp2) {
62775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62776     return 0;
62777   }
62778   arg2 = *argp2;
62779   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62780   arg4 = jarg4 ? true : false;
62781   {
62782     try {
62783       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62791       };
62792     } catch (...) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62795       };
62796     }
62797   }
62798   jresult = new Dali::Actor((const Dali::Actor &)result);
62799   return jresult;
62800 }
62801
62802
62803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62804   void * jresult ;
62805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62806   Dali::Actor arg2 ;
62807   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62808   bool arg4 ;
62809   Dali::Actor *argp2 ;
62810   Dali::Actor result;
62811
62812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62813   argp2 = (Dali::Actor *)jarg2;
62814   if (!argp2) {
62815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62816     return 0;
62817   }
62818   arg2 = *argp2;
62819   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62820   arg4 = jarg4 ? true : false;
62821   {
62822     try {
62823       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62824     } catch (std::out_of_range& e) {
62825       {
62826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (std::exception& e) {
62829       {
62830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62831       };
62832     } catch (...) {
62833       {
62834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62835       };
62836     }
62837   }
62838   jresult = new Dali::Actor((const Dali::Actor &)result);
62839   return jresult;
62840 }
62841
62842
62843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62845   Dali::Actor arg2 ;
62846   Dali::Actor *argp2 ;
62847
62848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62849   argp2 = (Dali::Actor *)jarg2;
62850   if (!argp2) {
62851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62852     return ;
62853   }
62854   arg2 = *argp2;
62855   {
62856     try {
62857       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62858     } catch (std::out_of_range& e) {
62859       {
62860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62861       };
62862     } catch (std::exception& e) {
62863       {
62864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62865       };
62866     } catch (...) {
62867       {
62868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62869       };
62870     }
62871   }
62872 }
62873
62874
62875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62877   Dali::Actor arg2 ;
62878   Dali::Actor *argp2 ;
62879
62880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62881   argp2 = (Dali::Actor *)jarg2;
62882   if (!argp2) {
62883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62884     return ;
62885   }
62886   arg2 = *argp2;
62887   {
62888     try {
62889       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62890     } catch (std::out_of_range& e) {
62891       {
62892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62893       };
62894     } catch (std::exception& e) {
62895       {
62896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62897       };
62898     } catch (...) {
62899       {
62900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62901       };
62902     }
62903   }
62904 }
62905
62906
62907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62908   unsigned int jresult ;
62909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62910   bool result;
62911
62912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62913   {
62914     try {
62915       result = (bool)(arg1)->OnKeyboardEnter();
62916     } catch (std::out_of_range& e) {
62917       {
62918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62919       };
62920     } catch (std::exception& e) {
62921       {
62922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62923       };
62924     } catch (...) {
62925       {
62926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62927       };
62928     }
62929   }
62930   jresult = result;
62931   return jresult;
62932 }
62933
62934
62935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62936   unsigned int jresult ;
62937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62938   bool result;
62939
62940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62941   {
62942     try {
62943       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62944     } catch (std::out_of_range& e) {
62945       {
62946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62947       };
62948     } catch (std::exception& e) {
62949       {
62950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62951       };
62952     } catch (...) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62955       };
62956     }
62957   }
62958   jresult = result;
62959   return jresult;
62960 }
62961
62962
62963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62965   Dali::PinchGesture *arg2 = 0 ;
62966
62967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62968   arg2 = (Dali::PinchGesture *)jarg2;
62969   if (!arg2) {
62970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62971     return ;
62972   }
62973   {
62974     try {
62975       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62976     } catch (std::out_of_range& e) {
62977       {
62978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62979       };
62980     } catch (std::exception& e) {
62981       {
62982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62983       };
62984     } catch (...) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62987       };
62988     }
62989   }
62990 }
62991
62992
62993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62994   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62995   Dali::PinchGesture *arg2 = 0 ;
62996
62997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62998   arg2 = (Dali::PinchGesture *)jarg2;
62999   if (!arg2) {
63000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63001     return ;
63002   }
63003   {
63004     try {
63005       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63006     } catch (std::out_of_range& e) {
63007       {
63008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63009       };
63010     } catch (std::exception& e) {
63011       {
63012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63017       };
63018     }
63019   }
63020 }
63021
63022
63023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63025   Dali::PanGesture *arg2 = 0 ;
63026
63027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63028   arg2 = (Dali::PanGesture *)jarg2;
63029   if (!arg2) {
63030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63031     return ;
63032   }
63033   {
63034     try {
63035       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63036     } catch (std::out_of_range& e) {
63037       {
63038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63039       };
63040     } catch (std::exception& e) {
63041       {
63042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63047       };
63048     }
63049   }
63050 }
63051
63052
63053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63055   Dali::PanGesture *arg2 = 0 ;
63056
63057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63058   arg2 = (Dali::PanGesture *)jarg2;
63059   if (!arg2) {
63060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63061     return ;
63062   }
63063   {
63064     try {
63065       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63066     } catch (std::out_of_range& e) {
63067       {
63068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63069       };
63070     } catch (std::exception& e) {
63071       {
63072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63077       };
63078     }
63079   }
63080 }
63081
63082
63083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63085   Dali::TapGesture *arg2 = 0 ;
63086
63087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63088   arg2 = (Dali::TapGesture *)jarg2;
63089   if (!arg2) {
63090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63091     return ;
63092   }
63093   {
63094     try {
63095       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63096     } catch (std::out_of_range& e) {
63097       {
63098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63099       };
63100     } catch (std::exception& e) {
63101       {
63102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63103       };
63104     } catch (...) {
63105       {
63106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63107       };
63108     }
63109   }
63110 }
63111
63112
63113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63115   Dali::TapGesture *arg2 = 0 ;
63116
63117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63118   arg2 = (Dali::TapGesture *)jarg2;
63119   if (!arg2) {
63120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63121     return ;
63122   }
63123   {
63124     try {
63125       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63126     } catch (std::out_of_range& e) {
63127       {
63128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63129       };
63130     } catch (std::exception& e) {
63131       {
63132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63133       };
63134     } catch (...) {
63135       {
63136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63137       };
63138     }
63139   }
63140 }
63141
63142
63143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63145   Dali::LongPressGesture *arg2 = 0 ;
63146
63147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63148   arg2 = (Dali::LongPressGesture *)jarg2;
63149   if (!arg2) {
63150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63151     return ;
63152   }
63153   {
63154     try {
63155       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63163       };
63164     } catch (...) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63167       };
63168     }
63169   }
63170 }
63171
63172
63173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63175   Dali::LongPressGesture *arg2 = 0 ;
63176
63177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63178   arg2 = (Dali::LongPressGesture *)jarg2;
63179   if (!arg2) {
63180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63181     return ;
63182   }
63183   {
63184     try {
63185       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63193       };
63194     } catch (...) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63197       };
63198     }
63199   }
63200 }
63201
63202
63203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63205   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63206   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63207
63208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63209   arg2 = (Dali::SlotObserver *)jarg2;
63210   arg3 = (Dali::CallbackBase *)jarg3;
63211   {
63212     try {
63213       (arg1)->SignalConnected(arg2,arg3);
63214     } catch (std::out_of_range& e) {
63215       {
63216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63217       };
63218     } catch (std::exception& e) {
63219       {
63220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63221       };
63222     } catch (...) {
63223       {
63224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63225       };
63226     }
63227   }
63228 }
63229
63230
63231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63233   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63234   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63235
63236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63237   arg2 = (Dali::SlotObserver *)jarg2;
63238   arg3 = (Dali::CallbackBase *)jarg3;
63239   {
63240     try {
63241       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63242     } catch (std::out_of_range& e) {
63243       {
63244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (std::exception& e) {
63247       {
63248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63253       };
63254     }
63255   }
63256 }
63257
63258
63259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63261   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63262   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63263
63264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63265   arg2 = (Dali::SlotObserver *)jarg2;
63266   arg3 = (Dali::CallbackBase *)jarg3;
63267   {
63268     try {
63269       (arg1)->SignalDisconnected(arg2,arg3);
63270     } catch (std::out_of_range& e) {
63271       {
63272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63273       };
63274     } catch (std::exception& e) {
63275       {
63276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63277       };
63278     } catch (...) {
63279       {
63280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63281       };
63282     }
63283   }
63284 }
63285
63286
63287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63289   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63290   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63291
63292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63293   arg2 = (Dali::SlotObserver *)jarg2;
63294   arg3 = (Dali::CallbackBase *)jarg3;
63295   {
63296     try {
63297       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63298     } catch (std::out_of_range& e) {
63299       {
63300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63301       };
63302     } catch (std::exception& e) {
63303       {
63304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63305       };
63306     } catch (...) {
63307       {
63308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63309       };
63310     }
63311   }
63312 }
63313
63314
63315 SWIGEXPORT 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) {
63316   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63317   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63318   if (director) {
63319     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);
63320   }
63321 }
63322
63323
63324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63325   void * jresult ;
63326   Dali::Toolkit::Control *arg1 = 0 ;
63327   Dali::Toolkit::Internal::Control *result = 0 ;
63328
63329   arg1 = (Dali::Toolkit::Control *)jarg1;
63330   if (!arg1) {
63331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63332     return 0;
63333   }
63334   {
63335     try {
63336       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63337     } catch (std::out_of_range& e) {
63338       {
63339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63340       };
63341     } catch (std::exception& e) {
63342       {
63343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (...) {
63346       {
63347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63348       };
63349     }
63350   }
63351   jresult = (void *)result;
63352   return jresult;
63353 }
63354
63355
63356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63357   int jresult ;
63358   int result;
63359
63360   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63361   jresult = (int)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63367   int jresult ;
63368   int result;
63369
63370   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63371   jresult = (int)result;
63372   return jresult;
63373 }
63374
63375
63376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63377   int jresult ;
63378   int result;
63379
63380   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63381   jresult = (int)result;
63382   return jresult;
63383 }
63384
63385
63386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63387   int jresult ;
63388   int result;
63389
63390   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63397   int jresult ;
63398   int result;
63399
63400   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63401   jresult = (int)result;
63402   return jresult;
63403 }
63404
63405
63406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63407   void * jresult ;
63408   Dali::Toolkit::Control::Property *result = 0 ;
63409
63410   {
63411     try {
63412       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63413     } catch (std::out_of_range& e) {
63414       {
63415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63416       };
63417     } catch (std::exception& e) {
63418       {
63419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63420       };
63421     } catch (...) {
63422       {
63423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63424       };
63425     }
63426   }
63427   jresult = (void *)result;
63428   return jresult;
63429 }
63430
63431
63432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63433   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63434
63435   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63436   {
63437     try {
63438       delete arg1;
63439     } catch (std::out_of_range& e) {
63440       {
63441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63442       };
63443     } catch (std::exception& e) {
63444       {
63445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63450       };
63451     }
63452   }
63453 }
63454
63455
63456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63457   void * jresult ;
63458   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63459
63460   {
63461     try {
63462       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63463     } catch (std::out_of_range& e) {
63464       {
63465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63466       };
63467     } catch (std::exception& e) {
63468       {
63469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63470       };
63471     } catch (...) {
63472       {
63473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63474       };
63475     }
63476   }
63477   jresult = (void *)result;
63478   return jresult;
63479 }
63480
63481
63482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63483   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63484
63485   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63486   {
63487     try {
63488       delete arg1;
63489     } catch (std::out_of_range& e) {
63490       {
63491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63492       };
63493     } catch (std::exception& e) {
63494       {
63495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63496       };
63497     } catch (...) {
63498       {
63499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63500       };
63501     }
63502   }
63503 }
63504
63505
63506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63507   void * jresult ;
63508   Dali::Toolkit::Control result;
63509
63510   {
63511     try {
63512       result = Dali::Toolkit::Control::New();
63513     } catch (std::out_of_range& e) {
63514       {
63515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63516       };
63517     } catch (std::exception& e) {
63518       {
63519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63520       };
63521     } catch (...) {
63522       {
63523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63524       };
63525     }
63526   }
63527   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63528   return jresult;
63529 }
63530
63531
63532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63533   void * jresult ;
63534   Dali::Toolkit::Control *result = 0 ;
63535
63536   {
63537     try {
63538       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (...) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63550       };
63551     }
63552   }
63553   jresult = (void *)result;
63554   return jresult;
63555 }
63556
63557
63558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63559   void * jresult ;
63560   Dali::Toolkit::Control *arg1 = 0 ;
63561   Dali::Toolkit::Control *result = 0 ;
63562
63563   arg1 = (Dali::Toolkit::Control *)jarg1;
63564   if (!arg1) {
63565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63566     return 0;
63567   }
63568   {
63569     try {
63570       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (...) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63582       };
63583     }
63584   }
63585   jresult = (void *)result;
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63592
63593   arg1 = (Dali::Toolkit::Control *)jarg1;
63594   {
63595     try {
63596       delete arg1;
63597     } catch (std::out_of_range& e) {
63598       {
63599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63600       };
63601     } catch (std::exception& e) {
63602       {
63603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63604       };
63605     } catch (...) {
63606       {
63607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63608       };
63609     }
63610   }
63611 }
63612
63613
63614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63615   void * jresult ;
63616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63617   Dali::Toolkit::Control *arg2 = 0 ;
63618   Dali::Toolkit::Control *result = 0 ;
63619
63620   arg1 = (Dali::Toolkit::Control *)jarg1;
63621   arg2 = (Dali::Toolkit::Control *)jarg2;
63622   if (!arg2) {
63623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63624     return 0;
63625   }
63626   {
63627     try {
63628       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63629     } catch (std::out_of_range& e) {
63630       {
63631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63632       };
63633     } catch (std::exception& e) {
63634       {
63635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (...) {
63638       {
63639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63640       };
63641     }
63642   }
63643   jresult = (void *)result;
63644   return jresult;
63645 }
63646
63647
63648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63649   void * jresult ;
63650   Dali::BaseHandle arg1 ;
63651   Dali::BaseHandle *argp1 ;
63652   Dali::Toolkit::Control result;
63653
63654   argp1 = (Dali::BaseHandle *)jarg1;
63655   if (!argp1) {
63656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63657     return 0;
63658   }
63659   arg1 = *argp1;
63660   {
63661     try {
63662       result = Dali::Toolkit::Control::DownCast(arg1);
63663     } catch (std::out_of_range& e) {
63664       {
63665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63666       };
63667     } catch (std::exception& e) {
63668       {
63669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (...) {
63672       {
63673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63674       };
63675     }
63676   }
63677   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63678   return jresult;
63679 }
63680
63681
63682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63683   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63684
63685   arg1 = (Dali::Toolkit::Control *)jarg1;
63686   {
63687     try {
63688       (arg1)->SetKeyInputFocus();
63689     } catch (std::out_of_range& e) {
63690       {
63691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63692       };
63693     } catch (std::exception& e) {
63694       {
63695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63696       };
63697     } catch (...) {
63698       {
63699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63700       };
63701     }
63702   }
63703 }
63704
63705
63706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63707   unsigned int jresult ;
63708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63709   bool result;
63710
63711   arg1 = (Dali::Toolkit::Control *)jarg1;
63712   {
63713     try {
63714       result = (bool)(arg1)->HasKeyInputFocus();
63715     } catch (std::out_of_range& e) {
63716       {
63717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63718       };
63719     } catch (std::exception& e) {
63720       {
63721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63722       };
63723     } catch (...) {
63724       {
63725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63726       };
63727     }
63728   }
63729   jresult = result;
63730   return jresult;
63731 }
63732
63733
63734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63735   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63736
63737   arg1 = (Dali::Toolkit::Control *)jarg1;
63738   {
63739     try {
63740       (arg1)->ClearKeyInputFocus();
63741     } catch (std::out_of_range& e) {
63742       {
63743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63744       };
63745     } catch (std::exception& e) {
63746       {
63747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63752       };
63753     }
63754   }
63755 }
63756
63757
63758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63759   void * jresult ;
63760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63761   Dali::PinchGestureDetector result;
63762
63763   arg1 = (Dali::Toolkit::Control *)jarg1;
63764   {
63765     try {
63766       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63767     } catch (std::out_of_range& e) {
63768       {
63769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63770       };
63771     } catch (std::exception& e) {
63772       {
63773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63778       };
63779     }
63780   }
63781   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63782   return jresult;
63783 }
63784
63785
63786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63787   void * jresult ;
63788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63789   Dali::PanGestureDetector result;
63790
63791   arg1 = (Dali::Toolkit::Control *)jarg1;
63792   {
63793     try {
63794       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63795     } catch (std::out_of_range& e) {
63796       {
63797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63798       };
63799     } catch (std::exception& e) {
63800       {
63801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63802       };
63803     } catch (...) {
63804       {
63805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63806       };
63807     }
63808   }
63809   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63810   return jresult;
63811 }
63812
63813
63814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63815   void * jresult ;
63816   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63817   Dali::TapGestureDetector result;
63818
63819   arg1 = (Dali::Toolkit::Control *)jarg1;
63820   {
63821     try {
63822       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63823     } catch (std::out_of_range& e) {
63824       {
63825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63826       };
63827     } catch (std::exception& e) {
63828       {
63829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63830       };
63831     } catch (...) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63834       };
63835     }
63836   }
63837   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63838   return jresult;
63839 }
63840
63841
63842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63843   void * jresult ;
63844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63845   Dali::LongPressGestureDetector result;
63846
63847   arg1 = (Dali::Toolkit::Control *)jarg1;
63848   {
63849     try {
63850       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63851     } catch (std::out_of_range& e) {
63852       {
63853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63854       };
63855     } catch (std::exception& e) {
63856       {
63857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63858       };
63859     } catch (...) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63862       };
63863     }
63864   }
63865   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63866   return jresult;
63867 }
63868
63869
63870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63871   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63872   std::string *arg2 = 0 ;
63873
63874   arg1 = (Dali::Toolkit::Control *)jarg1;
63875   if (!jarg2) {
63876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63877     return ;
63878   }
63879   std::string arg2_str(jarg2);
63880   arg2 = &arg2_str;
63881   {
63882     try {
63883       (arg1)->SetStyleName((std::string const &)*arg2);
63884     } catch (std::out_of_range& e) {
63885       {
63886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (std::exception& e) {
63889       {
63890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63895       };
63896     }
63897   }
63898
63899   //argout typemap for const std::string&
63900
63901 }
63902
63903
63904 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63905   char * jresult ;
63906   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63907   std::string *result = 0 ;
63908
63909   arg1 = (Dali::Toolkit::Control *)jarg1;
63910   {
63911     try {
63912       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (...) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63924       };
63925     }
63926   }
63927   jresult = SWIG_csharp_string_callback(result->c_str());
63928   return jresult;
63929 }
63930
63931
63932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63933   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63934   Dali::Vector4 *arg2 = 0 ;
63935
63936   arg1 = (Dali::Toolkit::Control *)jarg1;
63937   arg2 = (Dali::Vector4 *)jarg2;
63938   if (!arg2) {
63939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63940     return ;
63941   }
63942   {
63943     try {
63944       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63952       };
63953     } catch (...) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63956       };
63957     }
63958   }
63959 }
63960
63961
63962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63963   void * jresult ;
63964   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63965   Dali::Vector4 result;
63966
63967   arg1 = (Dali::Toolkit::Control *)jarg1;
63968   {
63969     try {
63970       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63971     } catch (std::out_of_range& e) {
63972       {
63973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63974       };
63975     } catch (std::exception& e) {
63976       {
63977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63978       };
63979     } catch (...) {
63980       {
63981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63982       };
63983     }
63984   }
63985   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63986   return jresult;
63987 }
63988
63989
63990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63991   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63992   Dali::Image arg2 ;
63993   Dali::Image *argp2 ;
63994
63995   arg1 = (Dali::Toolkit::Control *)jarg1;
63996   argp2 = (Dali::Image *)jarg2;
63997   if (!argp2) {
63998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63999     return ;
64000   }
64001   arg2 = *argp2;
64002   {
64003     try {
64004       (arg1)->SetBackgroundImage(arg2);
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64016       };
64017     }
64018   }
64019 }
64020
64021
64022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64023   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64024
64025   arg1 = (Dali::Toolkit::Control *)jarg1;
64026   {
64027     try {
64028       (arg1)->ClearBackground();
64029     } catch (std::out_of_range& e) {
64030       {
64031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64032       };
64033     } catch (std::exception& e) {
64034       {
64035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64036       };
64037     } catch (...) {
64038       {
64039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64040       };
64041     }
64042   }
64043 }
64044
64045
64046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64047   void * jresult ;
64048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64049   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64050
64051   arg1 = (Dali::Toolkit::Control *)jarg1;
64052   {
64053     try {
64054       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64055     } catch (std::out_of_range& e) {
64056       {
64057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64058       };
64059     } catch (std::exception& e) {
64060       {
64061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64062       };
64063     } catch (...) {
64064       {
64065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64066       };
64067     }
64068   }
64069   jresult = (void *)result;
64070   return jresult;
64071 }
64072
64073
64074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64075   void * jresult ;
64076   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64077   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64078
64079   arg1 = (Dali::Toolkit::Control *)jarg1;
64080   {
64081     try {
64082       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64083     } catch (std::out_of_range& e) {
64084       {
64085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64086       };
64087     } catch (std::exception& e) {
64088       {
64089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64090       };
64091     } catch (...) {
64092       {
64093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64094       };
64095     }
64096   }
64097   jresult = (void *)result;
64098   return jresult;
64099 }
64100
64101
64102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64103   void * jresult ;
64104   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64105   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64106
64107   arg1 = (Dali::Toolkit::Control *)jarg1;
64108   {
64109     try {
64110       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64111     } catch (std::out_of_range& e) {
64112       {
64113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64114       };
64115     } catch (std::exception& e) {
64116       {
64117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64118       };
64119     } catch (...) {
64120       {
64121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64122       };
64123     }
64124   }
64125   jresult = (void *)result;
64126   return jresult;
64127 }
64128
64129
64130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64131   void * jresult ;
64132   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64133   Dali::Toolkit::Control *result = 0 ;
64134
64135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64136   if (!arg1) {
64137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64138     return 0;
64139   }
64140   {
64141     try {
64142       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64143     } catch (std::out_of_range& e) {
64144       {
64145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64146       };
64147     } catch (std::exception& e) {
64148       {
64149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64150       };
64151     } catch (...) {
64152       {
64153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64154       };
64155     }
64156   }
64157   jresult = (void *)result;
64158   return jresult;
64159 }
64160
64161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64162   void * jresult ;
64163   Dali::Toolkit::Control *arg1 = 0 ;
64164   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64165
64166   arg1 = (Dali::Toolkit::Control *)jarg1;
64167   if (!arg1) {
64168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64169     return 0;
64170   }
64171   {
64172     try {
64173       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64174     } catch (std::out_of_range& e) {
64175       {
64176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64177       };
64178     } catch (std::exception& e) {
64179       {
64180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64181       };
64182     } catch (...) {
64183       {
64184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64185       };
64186     }
64187   }
64188   jresult = (void *)result;
64189   return jresult;
64190 }
64191
64192
64193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64194   unsigned int jresult ;
64195   Dali::Toolkit::Control *arg1 = 0 ;
64196   bool result;
64197
64198   arg1 = (Dali::Toolkit::Control *)jarg1;
64199   if (!arg1) {
64200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64201     return 0;
64202   }
64203   {
64204     try {
64205       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64206     } catch (std::out_of_range& e) {
64207       {
64208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64209       };
64210     } catch (std::exception& e) {
64211       {
64212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (...) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64217       };
64218     }
64219   }
64220   jresult = result;
64221   return jresult;
64222 }
64223
64224
64225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64226   void * jresult ;
64227   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64228
64229   {
64230     try {
64231       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64232     } catch (std::out_of_range& e) {
64233       {
64234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (std::exception& e) {
64237       {
64238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64239       };
64240     } catch (...) {
64241       {
64242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64243       };
64244     }
64245   }
64246   jresult = (void *)result;
64247   return jresult;
64248 }
64249
64250
64251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64252   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64253
64254   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64255   {
64256     try {
64257       delete arg1;
64258     } catch (std::out_of_range& e) {
64259       {
64260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64261       };
64262     } catch (std::exception& e) {
64263       {
64264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64265       };
64266     } catch (...) {
64267       {
64268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64269       };
64270     }
64271   }
64272 }
64273
64274
64275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64276   void * jresult ;
64277   Dali::Toolkit::KeyInputFocusManager result;
64278
64279   {
64280     try {
64281       result = Dali::Toolkit::KeyInputFocusManager::Get();
64282     } catch (std::out_of_range& e) {
64283       {
64284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64285       };
64286     } catch (std::exception& e) {
64287       {
64288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64289       };
64290     } catch (...) {
64291       {
64292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64293       };
64294     }
64295   }
64296   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64297   return jresult;
64298 }
64299
64300
64301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64302   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64303   Dali::Toolkit::Control arg2 ;
64304   Dali::Toolkit::Control *argp2 ;
64305
64306   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64307   argp2 = (Dali::Toolkit::Control *)jarg2;
64308   if (!argp2) {
64309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64310     return ;
64311   }
64312   arg2 = *argp2;
64313   {
64314     try {
64315       (arg1)->SetFocus(arg2);
64316     } catch (std::out_of_range& e) {
64317       {
64318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64319       };
64320     } catch (std::exception& e) {
64321       {
64322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64323       };
64324     } catch (...) {
64325       {
64326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64327       };
64328     }
64329   }
64330 }
64331
64332
64333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64334   void * jresult ;
64335   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64336   Dali::Toolkit::Control result;
64337
64338   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64339   {
64340     try {
64341       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64342     } catch (std::out_of_range& e) {
64343       {
64344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64345       };
64346     } catch (std::exception& e) {
64347       {
64348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64349       };
64350     } catch (...) {
64351       {
64352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64353       };
64354     }
64355   }
64356   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64357   return jresult;
64358 }
64359
64360
64361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64362   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64363   Dali::Toolkit::Control arg2 ;
64364   Dali::Toolkit::Control *argp2 ;
64365
64366   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64367   argp2 = (Dali::Toolkit::Control *)jarg2;
64368   if (!argp2) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64370     return ;
64371   }
64372   arg2 = *argp2;
64373   {
64374     try {
64375       (arg1)->RemoveFocus(arg2);
64376     } catch (std::out_of_range& e) {
64377       {
64378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64379       };
64380     } catch (std::exception& e) {
64381       {
64382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64383       };
64384     } catch (...) {
64385       {
64386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64387       };
64388     }
64389   }
64390 }
64391
64392
64393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64394   void * jresult ;
64395   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64396   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64397
64398   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64399   {
64400     try {
64401       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64402     } catch (std::out_of_range& e) {
64403       {
64404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64405       };
64406     } catch (std::exception& e) {
64407       {
64408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64409       };
64410     } catch (...) {
64411       {
64412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64413       };
64414     }
64415   }
64416   jresult = (void *)result;
64417   return jresult;
64418 }
64419
64420
64421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64422   void * jresult ;
64423   Dali::Toolkit::Alignment::Padding *result = 0 ;
64424
64425   {
64426     try {
64427       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64428     } catch (std::out_of_range& e) {
64429       {
64430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64431       };
64432     } catch (std::exception& e) {
64433       {
64434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64435       };
64436     } catch (...) {
64437       {
64438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64439       };
64440     }
64441   }
64442   jresult = (void *)result;
64443   return jresult;
64444 }
64445
64446
64447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64448   void * jresult ;
64449   float arg1 ;
64450   float arg2 ;
64451   float arg3 ;
64452   float arg4 ;
64453   Dali::Toolkit::Alignment::Padding *result = 0 ;
64454
64455   arg1 = (float)jarg1;
64456   arg2 = (float)jarg2;
64457   arg3 = (float)jarg3;
64458   arg4 = (float)jarg4;
64459   {
64460     try {
64461       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64462     } catch (std::out_of_range& e) {
64463       {
64464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64465       };
64466     } catch (std::exception& e) {
64467       {
64468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64469       };
64470     } catch (...) {
64471       {
64472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64473       };
64474     }
64475   }
64476   jresult = (void *)result;
64477   return jresult;
64478 }
64479
64480
64481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64482   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64483   float arg2 ;
64484
64485   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64486   arg2 = (float)jarg2;
64487   if (arg1) (arg1)->left = arg2;
64488 }
64489
64490
64491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64492   float jresult ;
64493   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64494   float result;
64495
64496   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64497   result = (float) ((arg1)->left);
64498   jresult = result;
64499   return jresult;
64500 }
64501
64502
64503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64504   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64505   float arg2 ;
64506
64507   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64508   arg2 = (float)jarg2;
64509   if (arg1) (arg1)->right = arg2;
64510 }
64511
64512
64513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64514   float jresult ;
64515   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64516   float result;
64517
64518   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64519   result = (float) ((arg1)->right);
64520   jresult = result;
64521   return jresult;
64522 }
64523
64524
64525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64526   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64527   float arg2 ;
64528
64529   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64530   arg2 = (float)jarg2;
64531   if (arg1) (arg1)->top = arg2;
64532 }
64533
64534
64535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64536   float jresult ;
64537   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64538   float result;
64539
64540   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64541   result = (float) ((arg1)->top);
64542   jresult = result;
64543   return jresult;
64544 }
64545
64546
64547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64548   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64549   float arg2 ;
64550
64551   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64552   arg2 = (float)jarg2;
64553   if (arg1) (arg1)->bottom = arg2;
64554 }
64555
64556
64557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64558   float jresult ;
64559   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64560   float result;
64561
64562   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64563   result = (float) ((arg1)->bottom);
64564   jresult = result;
64565   return jresult;
64566 }
64567
64568
64569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64570   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64571
64572   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64573   {
64574     try {
64575       delete arg1;
64576     } catch (std::out_of_range& e) {
64577       {
64578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64579       };
64580     } catch (std::exception& e) {
64581       {
64582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64583       };
64584     } catch (...) {
64585       {
64586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64587       };
64588     }
64589   }
64590 }
64591
64592
64593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64594   void * jresult ;
64595   Dali::Toolkit::Alignment *result = 0 ;
64596
64597   {
64598     try {
64599       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64600     } catch (std::out_of_range& e) {
64601       {
64602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64603       };
64604     } catch (std::exception& e) {
64605       {
64606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64607       };
64608     } catch (...) {
64609       {
64610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64611       };
64612     }
64613   }
64614   jresult = (void *)result;
64615   return jresult;
64616 }
64617
64618
64619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64620   void * jresult ;
64621   Dali::Toolkit::Alignment::Type arg1 ;
64622   Dali::Toolkit::Alignment::Type arg2 ;
64623   Dali::Toolkit::Alignment result;
64624
64625   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64626   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64627   {
64628     try {
64629       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64630     } catch (std::out_of_range& e) {
64631       {
64632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64633       };
64634     } catch (std::exception& e) {
64635       {
64636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64637       };
64638     } catch (...) {
64639       {
64640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64641       };
64642     }
64643   }
64644   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64645   return jresult;
64646 }
64647
64648
64649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64650   void * jresult ;
64651   Dali::Toolkit::Alignment::Type arg1 ;
64652   Dali::Toolkit::Alignment result;
64653
64654   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64655   {
64656     try {
64657       result = Dali::Toolkit::Alignment::New(arg1);
64658     } catch (std::out_of_range& e) {
64659       {
64660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (std::exception& e) {
64663       {
64664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64669       };
64670     }
64671   }
64672   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64673   return jresult;
64674 }
64675
64676
64677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64678   void * jresult ;
64679   Dali::Toolkit::Alignment result;
64680
64681   {
64682     try {
64683       result = Dali::Toolkit::Alignment::New();
64684     } catch (std::out_of_range& e) {
64685       {
64686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64687       };
64688     } catch (std::exception& e) {
64689       {
64690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64691       };
64692     } catch (...) {
64693       {
64694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64695       };
64696     }
64697   }
64698   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64699   return jresult;
64700 }
64701
64702
64703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64704   void * jresult ;
64705   Dali::Toolkit::Alignment *arg1 = 0 ;
64706   Dali::Toolkit::Alignment *result = 0 ;
64707
64708   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64709   if (!arg1) {
64710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64711     return 0;
64712   }
64713   {
64714     try {
64715       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64716     } catch (std::out_of_range& e) {
64717       {
64718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64719       };
64720     } catch (std::exception& e) {
64721       {
64722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64723       };
64724     } catch (...) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64727       };
64728     }
64729   }
64730   jresult = (void *)result;
64731   return jresult;
64732 }
64733
64734
64735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64736   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64737
64738   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64739   {
64740     try {
64741       delete arg1;
64742     } catch (std::out_of_range& e) {
64743       {
64744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64745       };
64746     } catch (std::exception& e) {
64747       {
64748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64749       };
64750     } catch (...) {
64751       {
64752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64753       };
64754     }
64755   }
64756 }
64757
64758
64759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64760   void * jresult ;
64761   Dali::BaseHandle arg1 ;
64762   Dali::BaseHandle *argp1 ;
64763   Dali::Toolkit::Alignment result;
64764
64765   argp1 = (Dali::BaseHandle *)jarg1;
64766   if (!argp1) {
64767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64768     return 0;
64769   }
64770   arg1 = *argp1;
64771   {
64772     try {
64773       result = Dali::Toolkit::Alignment::DownCast(arg1);
64774     } catch (std::out_of_range& e) {
64775       {
64776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64777       };
64778     } catch (std::exception& e) {
64779       {
64780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64781       };
64782     } catch (...) {
64783       {
64784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64785       };
64786     }
64787   }
64788   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64789   return jresult;
64790 }
64791
64792
64793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64794   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64795   Dali::Toolkit::Alignment::Type arg2 ;
64796
64797   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64798   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64799   {
64800     try {
64801       (arg1)->SetAlignmentType(arg2);
64802     } catch (std::out_of_range& e) {
64803       {
64804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64805       };
64806     } catch (std::exception& e) {
64807       {
64808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64809       };
64810     } catch (...) {
64811       {
64812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64813       };
64814     }
64815   }
64816 }
64817
64818
64819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64820   int jresult ;
64821   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64822   Dali::Toolkit::Alignment::Type result;
64823
64824   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64825   {
64826     try {
64827       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64828     } catch (std::out_of_range& e) {
64829       {
64830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64831       };
64832     } catch (std::exception& e) {
64833       {
64834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64835       };
64836     } catch (...) {
64837       {
64838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64839       };
64840     }
64841   }
64842   jresult = (int)result;
64843   return jresult;
64844 }
64845
64846
64847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64848   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64849   Dali::Toolkit::Alignment::Scaling arg2 ;
64850
64851   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64852   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64853   {
64854     try {
64855       (arg1)->SetScaling(arg2);
64856     } catch (std::out_of_range& e) {
64857       {
64858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64859       };
64860     } catch (std::exception& e) {
64861       {
64862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64863       };
64864     } catch (...) {
64865       {
64866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64867       };
64868     }
64869   }
64870 }
64871
64872
64873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64874   int jresult ;
64875   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64876   Dali::Toolkit::Alignment::Scaling result;
64877
64878   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64879   {
64880     try {
64881       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64882     } catch (std::out_of_range& e) {
64883       {
64884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64885       };
64886     } catch (std::exception& e) {
64887       {
64888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64889       };
64890     } catch (...) {
64891       {
64892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64893       };
64894     }
64895   }
64896   jresult = (int)result;
64897   return jresult;
64898 }
64899
64900
64901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64902   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64903   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64904
64905   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64906   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64907   if (!arg2) {
64908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64909     return ;
64910   }
64911   {
64912     try {
64913       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64914     } catch (std::out_of_range& e) {
64915       {
64916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64917       };
64918     } catch (std::exception& e) {
64919       {
64920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64921       };
64922     } catch (...) {
64923       {
64924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64925       };
64926     }
64927   }
64928 }
64929
64930
64931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64932   void * jresult ;
64933   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64934   Dali::Toolkit::Alignment::Padding *result = 0 ;
64935
64936   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64937   {
64938     try {
64939       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
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 = (void *)result;
64955   return jresult;
64956 }
64957
64958
64959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64960   void * jresult ;
64961   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64962   Dali::Toolkit::Alignment *arg2 = 0 ;
64963   Dali::Toolkit::Alignment *result = 0 ;
64964
64965   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64966   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64967   if (!arg2) {
64968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64969     return 0;
64970   }
64971   {
64972     try {
64973       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64974     } catch (std::out_of_range& e) {
64975       {
64976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64977       };
64978     } catch (std::exception& e) {
64979       {
64980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64981       };
64982     } catch (...) {
64983       {
64984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64985       };
64986     }
64987   }
64988   jresult = (void *)result;
64989   return jresult;
64990 }
64991
64992
64993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64994   int jresult ;
64995   int result;
64996
64997   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64998   jresult = (int)result;
64999   return jresult;
65000 }
65001
65002
65003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65004   int jresult ;
65005   int result;
65006
65007   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65008   jresult = (int)result;
65009   return jresult;
65010 }
65011
65012
65013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65014   int jresult ;
65015   int result;
65016
65017   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65018   jresult = (int)result;
65019   return jresult;
65020 }
65021
65022
65023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65024   int jresult ;
65025   int result;
65026
65027   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65028   jresult = (int)result;
65029   return jresult;
65030 }
65031
65032
65033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65034   int jresult ;
65035   int result;
65036
65037   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65038   jresult = (int)result;
65039   return jresult;
65040 }
65041
65042
65043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65044   int jresult ;
65045   int result;
65046
65047   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65048   jresult = (int)result;
65049   return jresult;
65050 }
65051
65052
65053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
65054   int jresult ;
65055   int result;
65056
65057   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
65058   jresult = (int)result;
65059   return jresult;
65060 }
65061
65062
65063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
65064   int jresult ;
65065   int result;
65066
65067   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
65068   jresult = (int)result;
65069   return jresult;
65070 }
65071
65072
65073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65074   int jresult ;
65075   int result;
65076
65077   result = (int)Dali::Toolkit::Button::Property::LABEL;
65078   jresult = (int)result;
65079   return jresult;
65080 }
65081
65082
65083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65084   int jresult ;
65085   int result;
65086
65087   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65088   jresult = (int)result;
65089   return jresult;
65090 }
65091
65092
65093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65094   void * jresult ;
65095   Dali::Toolkit::Button::Property *result = 0 ;
65096
65097   {
65098     try {
65099       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65100     } catch (std::out_of_range& e) {
65101       {
65102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65103       };
65104     } catch (std::exception& e) {
65105       {
65106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65107       };
65108     } catch (...) {
65109       {
65110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65111       };
65112     }
65113   }
65114   jresult = (void *)result;
65115   return jresult;
65116 }
65117
65118
65119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65120   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65121
65122   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65123   {
65124     try {
65125       delete arg1;
65126     } catch (std::out_of_range& e) {
65127       {
65128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65129       };
65130     } catch (std::exception& e) {
65131       {
65132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65133       };
65134     } catch (...) {
65135       {
65136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65137       };
65138     }
65139   }
65140 }
65141
65142
65143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65144   void * jresult ;
65145   Dali::Toolkit::Button *result = 0 ;
65146
65147   {
65148     try {
65149       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65150     } catch (std::out_of_range& e) {
65151       {
65152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65153       };
65154     } catch (std::exception& e) {
65155       {
65156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65157       };
65158     } catch (...) {
65159       {
65160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65161       };
65162     }
65163   }
65164   jresult = (void *)result;
65165   return jresult;
65166 }
65167
65168
65169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65170   void * jresult ;
65171   Dali::Toolkit::Button *arg1 = 0 ;
65172   Dali::Toolkit::Button *result = 0 ;
65173
65174   arg1 = (Dali::Toolkit::Button *)jarg1;
65175   if (!arg1) {
65176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65177     return 0;
65178   }
65179   {
65180     try {
65181       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65182     } catch (std::out_of_range& e) {
65183       {
65184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (std::exception& e) {
65187       {
65188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196   jresult = (void *)result;
65197   return jresult;
65198 }
65199
65200
65201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65202   void * jresult ;
65203   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65204   Dali::Toolkit::Button *arg2 = 0 ;
65205   Dali::Toolkit::Button *result = 0 ;
65206
65207   arg1 = (Dali::Toolkit::Button *)jarg1;
65208   arg2 = (Dali::Toolkit::Button *)jarg2;
65209   if (!arg2) {
65210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65211     return 0;
65212   }
65213   {
65214     try {
65215       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65216     } catch (std::out_of_range& e) {
65217       {
65218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65219       };
65220     } catch (std::exception& e) {
65221       {
65222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65223       };
65224     } catch (...) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65227       };
65228     }
65229   }
65230   jresult = (void *)result;
65231   return jresult;
65232 }
65233
65234
65235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65236   void * jresult ;
65237   Dali::BaseHandle arg1 ;
65238   Dali::BaseHandle *argp1 ;
65239   Dali::Toolkit::Button result;
65240
65241   argp1 = (Dali::BaseHandle *)jarg1;
65242   if (!argp1) {
65243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65244     return 0;
65245   }
65246   arg1 = *argp1;
65247   {
65248     try {
65249       result = Dali::Toolkit::Button::DownCast(arg1);
65250     } catch (std::out_of_range& e) {
65251       {
65252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65253       };
65254     } catch (std::exception& e) {
65255       {
65256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65257       };
65258     } catch (...) {
65259       {
65260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65261       };
65262     }
65263   }
65264   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65265   return jresult;
65266 }
65267
65268
65269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65270   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65271
65272   arg1 = (Dali::Toolkit::Button *)jarg1;
65273   {
65274     try {
65275       delete arg1;
65276     } catch (std::out_of_range& e) {
65277       {
65278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65279       };
65280     } catch (std::exception& e) {
65281       {
65282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65283       };
65284     } catch (...) {
65285       {
65286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65287       };
65288     }
65289   }
65290 }
65291
65292
65293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65294   unsigned int jresult ;
65295   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65296   bool result;
65297
65298   arg1 = (Dali::Toolkit::Button *)jarg1;
65299   {
65300     try {
65301       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65302     } catch (std::out_of_range& e) {
65303       {
65304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65305       };
65306     } catch (std::exception& e) {
65307       {
65308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65309       };
65310     } catch (...) {
65311       {
65312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65313       };
65314     }
65315   }
65316   jresult = result;
65317   return jresult;
65318 }
65319
65320
65321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65322   unsigned int jresult ;
65323   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65324   bool result;
65325
65326   arg1 = (Dali::Toolkit::Button *)jarg1;
65327   {
65328     try {
65329       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65330     } catch (std::out_of_range& e) {
65331       {
65332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65333       };
65334     } catch (std::exception& e) {
65335       {
65336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65337       };
65338     } catch (...) {
65339       {
65340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65341       };
65342     }
65343   }
65344   jresult = result;
65345   return jresult;
65346 }
65347
65348
65349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65350   float jresult ;
65351   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65352   float result;
65353
65354   arg1 = (Dali::Toolkit::Button *)jarg1;
65355   {
65356     try {
65357       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65358     } catch (std::out_of_range& e) {
65359       {
65360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65361       };
65362     } catch (std::exception& e) {
65363       {
65364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65365       };
65366     } catch (...) {
65367       {
65368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65369       };
65370     }
65371   }
65372   jresult = result;
65373   return jresult;
65374 }
65375
65376
65377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65378   float jresult ;
65379   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65380   float result;
65381
65382   arg1 = (Dali::Toolkit::Button *)jarg1;
65383   {
65384     try {
65385       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65386     } catch (std::out_of_range& e) {
65387       {
65388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65389       };
65390     } catch (std::exception& e) {
65391       {
65392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65393       };
65394     } catch (...) {
65395       {
65396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65397       };
65398     }
65399   }
65400   jresult = result;
65401   return jresult;
65402 }
65403
65404
65405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65406   unsigned int jresult ;
65407   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65408   bool result;
65409
65410   arg1 = (Dali::Toolkit::Button *)jarg1;
65411   {
65412     try {
65413       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65414     } catch (std::out_of_range& e) {
65415       {
65416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65417       };
65418     } catch (std::exception& e) {
65419       {
65420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65421       };
65422     } catch (...) {
65423       {
65424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65425       };
65426     }
65427   }
65428   jresult = result;
65429   return jresult;
65430 }
65431
65432
65433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65434   unsigned int jresult ;
65435   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65436   bool result;
65437
65438   arg1 = (Dali::Toolkit::Button *)jarg1;
65439   {
65440     try {
65441       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65442     } catch (std::out_of_range& e) {
65443       {
65444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65445       };
65446     } catch (std::exception& e) {
65447       {
65448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65449       };
65450     } catch (...) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65453       };
65454     }
65455   }
65456   jresult = result;
65457   return jresult;
65458 }
65459
65460
65461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65462   float jresult ;
65463   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65464   float result;
65465
65466   arg1 = (Dali::Toolkit::Button *)jarg1;
65467   {
65468     try {
65469       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65470     } catch (std::out_of_range& e) {
65471       {
65472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65473       };
65474     } catch (std::exception& e) {
65475       {
65476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65477       };
65478     } catch (...) {
65479       {
65480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65481       };
65482     }
65483   }
65484   jresult = result;
65485   return jresult;
65486 }
65487
65488
65489 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65490   char * jresult ;
65491   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65492   std::string result;
65493
65494   arg1 = (Dali::Toolkit::Button *)jarg1;
65495   {
65496     try {
65497       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65498     } catch (std::out_of_range& e) {
65499       {
65500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65501       };
65502     } catch (std::exception& e) {
65503       {
65504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65505       };
65506     } catch (...) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65509       };
65510     }
65511   }
65512   jresult = SWIG_csharp_string_callback((&result)->c_str());
65513   return jresult;
65514 }
65515
65516
65517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65518   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65519   Dali::Actor arg2 ;
65520   Dali::Actor *argp2 ;
65521
65522   arg1 = (Dali::Toolkit::Button *)jarg1;
65523   argp2 = (Dali::Actor *)jarg2;
65524   if (!argp2) {
65525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65526     return ;
65527   }
65528   arg2 = *argp2;
65529   {
65530     try {
65531       (arg1)->SetLabel(arg2);
65532     } catch (std::out_of_range& e) {
65533       {
65534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65535       };
65536     } catch (std::exception& e) {
65537       {
65538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65539       };
65540     } catch (...) {
65541       {
65542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65543       };
65544     }
65545   }
65546 }
65547
65548
65549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65550   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65551   Dali::Image arg2 ;
65552   Dali::Image *argp2 ;
65553
65554   arg1 = (Dali::Toolkit::Button *)jarg1;
65555   argp2 = (Dali::Image *)jarg2;
65556   if (!argp2) {
65557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65558     return ;
65559   }
65560   arg2 = *argp2;
65561   {
65562     try {
65563       (arg1)->SetButtonImage(arg2);
65564     } catch (std::out_of_range& e) {
65565       {
65566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65567       };
65568     } catch (std::exception& e) {
65569       {
65570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65571       };
65572     } catch (...) {
65573       {
65574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65575       };
65576     }
65577   }
65578 }
65579
65580
65581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65582   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65583   Dali::Image arg2 ;
65584   Dali::Image *argp2 ;
65585
65586   arg1 = (Dali::Toolkit::Button *)jarg1;
65587   argp2 = (Dali::Image *)jarg2;
65588   if (!argp2) {
65589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65590     return ;
65591   }
65592   arg2 = *argp2;
65593   {
65594     try {
65595       (arg1)->SetSelectedImage(arg2);
65596     } catch (std::out_of_range& e) {
65597       {
65598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65599       };
65600     } catch (std::exception& e) {
65601       {
65602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65603       };
65604     } catch (...) {
65605       {
65606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65607       };
65608     }
65609   }
65610 }
65611
65612
65613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65614   void * jresult ;
65615   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65616   Dali::Actor result;
65617
65618   arg1 = (Dali::Toolkit::Button *)jarg1;
65619   {
65620     try {
65621       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65622     } catch (std::out_of_range& e) {
65623       {
65624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65625       };
65626     } catch (std::exception& e) {
65627       {
65628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65629       };
65630     } catch (...) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65633       };
65634     }
65635   }
65636   jresult = new Dali::Actor((const Dali::Actor &)result);
65637   return jresult;
65638 }
65639
65640
65641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65642   void * jresult ;
65643   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65644   Dali::Actor result;
65645
65646   arg1 = (Dali::Toolkit::Button *)jarg1;
65647   {
65648     try {
65649       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65650     } catch (std::out_of_range& e) {
65651       {
65652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (std::exception& e) {
65655       {
65656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65657       };
65658     } catch (...) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65661       };
65662     }
65663   }
65664   jresult = new Dali::Actor((const Dali::Actor &)result);
65665   return jresult;
65666 }
65667
65668
65669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65670   void * jresult ;
65671   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65672   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65673
65674   arg1 = (Dali::Toolkit::Button *)jarg1;
65675   {
65676     try {
65677       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65678     } catch (std::out_of_range& e) {
65679       {
65680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65681       };
65682     } catch (std::exception& e) {
65683       {
65684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65685       };
65686     } catch (...) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65689       };
65690     }
65691   }
65692   jresult = (void *)result;
65693   return jresult;
65694 }
65695
65696
65697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65698   void * jresult ;
65699   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65700   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65701
65702   arg1 = (Dali::Toolkit::Button *)jarg1;
65703   {
65704     try {
65705       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65706     } catch (std::out_of_range& e) {
65707       {
65708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (std::exception& e) {
65711       {
65712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65713       };
65714     } catch (...) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65717       };
65718     }
65719   }
65720   jresult = (void *)result;
65721   return jresult;
65722 }
65723
65724
65725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65726   void * jresult ;
65727   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65728   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65729
65730   arg1 = (Dali::Toolkit::Button *)jarg1;
65731   {
65732     try {
65733       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65734     } catch (std::out_of_range& e) {
65735       {
65736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65737       };
65738     } catch (std::exception& e) {
65739       {
65740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65741       };
65742     } catch (...) {
65743       {
65744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65745       };
65746     }
65747   }
65748   jresult = (void *)result;
65749   return jresult;
65750 }
65751
65752
65753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65754   void * jresult ;
65755   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65756   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65757
65758   arg1 = (Dali::Toolkit::Button *)jarg1;
65759   {
65760     try {
65761       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65762     } catch (std::out_of_range& e) {
65763       {
65764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65765       };
65766     } catch (std::exception& e) {
65767       {
65768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65769       };
65770     } catch (...) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65773       };
65774     }
65775   }
65776   jresult = (void *)result;
65777   return jresult;
65778 }
65779
65780
65781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65782   void * jresult ;
65783   Dali::Toolkit::CheckBoxButton *result = 0 ;
65784
65785   {
65786     try {
65787       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65788     } catch (std::out_of_range& e) {
65789       {
65790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65791       };
65792     } catch (std::exception& e) {
65793       {
65794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65795       };
65796     } catch (...) {
65797       {
65798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65799       };
65800     }
65801   }
65802   jresult = (void *)result;
65803   return jresult;
65804 }
65805
65806
65807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65808   void * jresult ;
65809   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65810   Dali::Toolkit::CheckBoxButton *result = 0 ;
65811
65812   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65813   if (!arg1) {
65814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65815     return 0;
65816   }
65817   {
65818     try {
65819       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65820     } catch (std::out_of_range& e) {
65821       {
65822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65823       };
65824     } catch (std::exception& e) {
65825       {
65826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65827       };
65828     } catch (...) {
65829       {
65830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65831       };
65832     }
65833   }
65834   jresult = (void *)result;
65835   return jresult;
65836 }
65837
65838
65839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65840   void * jresult ;
65841   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65842   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65843   Dali::Toolkit::CheckBoxButton *result = 0 ;
65844
65845   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65846   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65847   if (!arg2) {
65848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65849     return 0;
65850   }
65851   {
65852     try {
65853       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65854     } catch (std::out_of_range& e) {
65855       {
65856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65857       };
65858     } catch (std::exception& e) {
65859       {
65860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65861       };
65862     } catch (...) {
65863       {
65864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65865       };
65866     }
65867   }
65868   jresult = (void *)result;
65869   return jresult;
65870 }
65871
65872
65873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65874   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65875
65876   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65877   {
65878     try {
65879       delete arg1;
65880     } catch (std::out_of_range& e) {
65881       {
65882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65883       };
65884     } catch (std::exception& e) {
65885       {
65886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65887       };
65888     } catch (...) {
65889       {
65890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65891       };
65892     }
65893   }
65894 }
65895
65896
65897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65898   void * jresult ;
65899   Dali::Toolkit::CheckBoxButton result;
65900
65901   {
65902     try {
65903       result = Dali::Toolkit::CheckBoxButton::New();
65904     } catch (std::out_of_range& e) {
65905       {
65906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65907       };
65908     } catch (std::exception& e) {
65909       {
65910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (...) {
65913       {
65914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65915       };
65916     }
65917   }
65918   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65919   return jresult;
65920 }
65921
65922
65923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65924   void * jresult ;
65925   Dali::BaseHandle arg1 ;
65926   Dali::BaseHandle *argp1 ;
65927   Dali::Toolkit::CheckBoxButton result;
65928
65929   argp1 = (Dali::BaseHandle *)jarg1;
65930   if (!argp1) {
65931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65932     return 0;
65933   }
65934   arg1 = *argp1;
65935   {
65936     try {
65937       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65945       };
65946     } catch (...) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65949       };
65950     }
65951   }
65952   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65953   return jresult;
65954 }
65955
65956
65957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65958   int jresult ;
65959   int result;
65960
65961   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65962   jresult = (int)result;
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65968   int jresult ;
65969   int result;
65970
65971   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65972   jresult = (int)result;
65973   return jresult;
65974 }
65975
65976
65977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65978   int jresult ;
65979   int result;
65980
65981   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65982   jresult = (int)result;
65983   return jresult;
65984 }
65985
65986
65987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65988   int jresult ;
65989   int result;
65990
65991   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65992   jresult = (int)result;
65993   return jresult;
65994 }
65995
65996
65997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65998   int jresult ;
65999   int result;
66000
66001   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66002   jresult = (int)result;
66003   return jresult;
66004 }
66005
66006
66007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66008   void * jresult ;
66009   Dali::Toolkit::PushButton::Property *result = 0 ;
66010
66011   {
66012     try {
66013       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
66014     } catch (std::out_of_range& e) {
66015       {
66016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66017       };
66018     } catch (std::exception& e) {
66019       {
66020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66021       };
66022     } catch (...) {
66023       {
66024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66025       };
66026     }
66027   }
66028   jresult = (void *)result;
66029   return jresult;
66030 }
66031
66032
66033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
66034   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66035
66036   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
66037   {
66038     try {
66039       delete arg1;
66040     } catch (std::out_of_range& e) {
66041       {
66042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66043       };
66044     } catch (std::exception& e) {
66045       {
66046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66047       };
66048     } catch (...) {
66049       {
66050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66051       };
66052     }
66053   }
66054 }
66055
66056
66057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
66058   void * jresult ;
66059   Dali::Toolkit::PushButton *result = 0 ;
66060
66061   {
66062     try {
66063       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
66064     } catch (std::out_of_range& e) {
66065       {
66066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66067       };
66068     } catch (std::exception& e) {
66069       {
66070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (...) {
66073       {
66074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66075       };
66076     }
66077   }
66078   jresult = (void *)result;
66079   return jresult;
66080 }
66081
66082
66083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66084   void * jresult ;
66085   Dali::Toolkit::PushButton *arg1 = 0 ;
66086   Dali::Toolkit::PushButton *result = 0 ;
66087
66088   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66089   if (!arg1) {
66090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66091     return 0;
66092   }
66093   {
66094     try {
66095       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66096     } catch (std::out_of_range& e) {
66097       {
66098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66099       };
66100     } catch (std::exception& e) {
66101       {
66102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66103       };
66104     } catch (...) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66107       };
66108     }
66109   }
66110   jresult = (void *)result;
66111   return jresult;
66112 }
66113
66114
66115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66116   void * jresult ;
66117   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66118   Dali::Toolkit::PushButton *arg2 = 0 ;
66119   Dali::Toolkit::PushButton *result = 0 ;
66120
66121   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66122   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66123   if (!arg2) {
66124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66125     return 0;
66126   }
66127   {
66128     try {
66129       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66130     } catch (std::out_of_range& e) {
66131       {
66132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66133       };
66134     } catch (std::exception& e) {
66135       {
66136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66137       };
66138     } catch (...) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66141       };
66142     }
66143   }
66144   jresult = (void *)result;
66145   return jresult;
66146 }
66147
66148
66149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66150   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66151
66152   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66153   {
66154     try {
66155       delete arg1;
66156     } catch (std::out_of_range& e) {
66157       {
66158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66159       };
66160     } catch (std::exception& e) {
66161       {
66162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66163       };
66164     } catch (...) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66167       };
66168     }
66169   }
66170 }
66171
66172
66173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66174   void * jresult ;
66175   Dali::Toolkit::PushButton result;
66176
66177   {
66178     try {
66179       result = Dali::Toolkit::PushButton::New();
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66187       };
66188     } catch (...) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66191       };
66192     }
66193   }
66194   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66195   return jresult;
66196 }
66197
66198
66199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66200   void * jresult ;
66201   Dali::BaseHandle arg1 ;
66202   Dali::BaseHandle *argp1 ;
66203   Dali::Toolkit::PushButton result;
66204
66205   argp1 = (Dali::BaseHandle *)jarg1;
66206   if (!argp1) {
66207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66208     return 0;
66209   }
66210   arg1 = *argp1;
66211   {
66212     try {
66213       result = Dali::Toolkit::PushButton::DownCast(arg1);
66214     } catch (std::out_of_range& e) {
66215       {
66216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66217       };
66218     } catch (std::exception& e) {
66219       {
66220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66221       };
66222     } catch (...) {
66223       {
66224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66225       };
66226     }
66227   }
66228   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66229   return jresult;
66230 }
66231
66232
66233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66234   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66235   Dali::Image arg2 ;
66236   Dali::Image *argp2 ;
66237
66238   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66239   argp2 = (Dali::Image *)jarg2;
66240   if (!argp2) {
66241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66242     return ;
66243   }
66244   arg2 = *argp2;
66245   {
66246     try {
66247       (arg1)->SetButtonImage(arg2);
66248     } catch (std::out_of_range& e) {
66249       {
66250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66251       };
66252     } catch (std::exception& e) {
66253       {
66254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66255       };
66256     } catch (...) {
66257       {
66258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66259       };
66260     }
66261   }
66262 }
66263
66264
66265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66266   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66267   Dali::Actor arg2 ;
66268   Dali::Actor *argp2 ;
66269
66270   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66271   argp2 = (Dali::Actor *)jarg2;
66272   if (!argp2) {
66273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66274     return ;
66275   }
66276   arg2 = *argp2;
66277   {
66278     try {
66279       (arg1)->SetButtonImage(arg2);
66280     } catch (std::out_of_range& e) {
66281       {
66282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66283       };
66284     } catch (std::exception& e) {
66285       {
66286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66287       };
66288     } catch (...) {
66289       {
66290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66291       };
66292     }
66293   }
66294 }
66295
66296
66297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66298   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66299   Dali::Actor arg2 ;
66300   Dali::Actor *argp2 ;
66301
66302   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66303   argp2 = (Dali::Actor *)jarg2;
66304   if (!argp2) {
66305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66306     return ;
66307   }
66308   arg2 = *argp2;
66309   {
66310     try {
66311       (arg1)->SetBackgroundImage(arg2);
66312     } catch (std::out_of_range& e) {
66313       {
66314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66315       };
66316     } catch (std::exception& e) {
66317       {
66318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66319       };
66320     } catch (...) {
66321       {
66322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66323       };
66324     }
66325   }
66326 }
66327
66328
66329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66330   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66331   Dali::Image arg2 ;
66332   Dali::Image *argp2 ;
66333
66334   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66335   argp2 = (Dali::Image *)jarg2;
66336   if (!argp2) {
66337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66338     return ;
66339   }
66340   arg2 = *argp2;
66341   {
66342     try {
66343       (arg1)->SetSelectedImage(arg2);
66344     } catch (std::out_of_range& e) {
66345       {
66346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66347       };
66348     } catch (std::exception& e) {
66349       {
66350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66351       };
66352     } catch (...) {
66353       {
66354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66355       };
66356     }
66357   }
66358 }
66359
66360
66361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66362   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66363   Dali::Actor arg2 ;
66364   Dali::Actor *argp2 ;
66365
66366   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66367   argp2 = (Dali::Actor *)jarg2;
66368   if (!argp2) {
66369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66370     return ;
66371   }
66372   arg2 = *argp2;
66373   {
66374     try {
66375       (arg1)->SetSelectedImage(arg2);
66376     } catch (std::out_of_range& e) {
66377       {
66378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66379       };
66380     } catch (std::exception& e) {
66381       {
66382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66383       };
66384     } catch (...) {
66385       {
66386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66387       };
66388     }
66389   }
66390 }
66391
66392
66393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66394   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66395   Dali::Actor arg2 ;
66396   Dali::Actor *argp2 ;
66397
66398   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66399   argp2 = (Dali::Actor *)jarg2;
66400   if (!argp2) {
66401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66402     return ;
66403   }
66404   arg2 = *argp2;
66405   {
66406     try {
66407       (arg1)->SetSelectedBackgroundImage(arg2);
66408     } catch (std::out_of_range& e) {
66409       {
66410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66411       };
66412     } catch (std::exception& e) {
66413       {
66414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66415       };
66416     } catch (...) {
66417       {
66418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66419       };
66420     }
66421   }
66422 }
66423
66424
66425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66426   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66427   Dali::Actor arg2 ;
66428   Dali::Actor *argp2 ;
66429
66430   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66431   argp2 = (Dali::Actor *)jarg2;
66432   if (!argp2) {
66433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66434     return ;
66435   }
66436   arg2 = *argp2;
66437   {
66438     try {
66439       (arg1)->SetDisabledBackgroundImage(arg2);
66440     } catch (std::out_of_range& e) {
66441       {
66442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66443       };
66444     } catch (std::exception& e) {
66445       {
66446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66447       };
66448     } catch (...) {
66449       {
66450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66451       };
66452     }
66453   }
66454 }
66455
66456
66457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66458   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66459   Dali::Actor arg2 ;
66460   Dali::Actor *argp2 ;
66461
66462   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66463   argp2 = (Dali::Actor *)jarg2;
66464   if (!argp2) {
66465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66466     return ;
66467   }
66468   arg2 = *argp2;
66469   {
66470     try {
66471       (arg1)->SetDisabledImage(arg2);
66472     } catch (std::out_of_range& e) {
66473       {
66474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66475       };
66476     } catch (std::exception& e) {
66477       {
66478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66479       };
66480     } catch (...) {
66481       {
66482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66483       };
66484     }
66485   }
66486 }
66487
66488
66489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66490   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66491   Dali::Actor arg2 ;
66492   Dali::Actor *argp2 ;
66493
66494   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66495   argp2 = (Dali::Actor *)jarg2;
66496   if (!argp2) {
66497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66498     return ;
66499   }
66500   arg2 = *argp2;
66501   {
66502     try {
66503       (arg1)->SetDisabledSelectedImage(arg2);
66504     } catch (std::out_of_range& e) {
66505       {
66506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66507       };
66508     } catch (std::exception& e) {
66509       {
66510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66511       };
66512     } catch (...) {
66513       {
66514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66515       };
66516     }
66517   }
66518 }
66519
66520
66521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66522   void * jresult ;
66523   Dali::Toolkit::RadioButton *result = 0 ;
66524
66525   {
66526     try {
66527       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66528     } catch (std::out_of_range& e) {
66529       {
66530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66531       };
66532     } catch (std::exception& e) {
66533       {
66534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66535       };
66536     } catch (...) {
66537       {
66538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66539       };
66540     }
66541   }
66542   jresult = (void *)result;
66543   return jresult;
66544 }
66545
66546
66547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66548   void * jresult ;
66549   Dali::Toolkit::RadioButton *arg1 = 0 ;
66550   Dali::Toolkit::RadioButton *result = 0 ;
66551
66552   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66553   if (!arg1) {
66554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66555     return 0;
66556   }
66557   {
66558     try {
66559       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66560     } catch (std::out_of_range& e) {
66561       {
66562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66563       };
66564     } catch (std::exception& e) {
66565       {
66566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66567       };
66568     } catch (...) {
66569       {
66570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66571       };
66572     }
66573   }
66574   jresult = (void *)result;
66575   return jresult;
66576 }
66577
66578
66579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66580   void * jresult ;
66581   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66582   Dali::Toolkit::RadioButton *arg2 = 0 ;
66583   Dali::Toolkit::RadioButton *result = 0 ;
66584
66585   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66586   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66587   if (!arg2) {
66588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66589     return 0;
66590   }
66591   {
66592     try {
66593       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66594     } catch (std::out_of_range& e) {
66595       {
66596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (std::exception& e) {
66599       {
66600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66601       };
66602     } catch (...) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66605       };
66606     }
66607   }
66608   jresult = (void *)result;
66609   return jresult;
66610 }
66611
66612
66613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66614   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66615
66616   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66617   {
66618     try {
66619       delete arg1;
66620     } catch (std::out_of_range& e) {
66621       {
66622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66623       };
66624     } catch (std::exception& e) {
66625       {
66626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66627       };
66628     } catch (...) {
66629       {
66630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66631       };
66632     }
66633   }
66634 }
66635
66636
66637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66638   void * jresult ;
66639   Dali::Toolkit::RadioButton result;
66640
66641   {
66642     try {
66643       result = Dali::Toolkit::RadioButton::New();
66644     } catch (std::out_of_range& e) {
66645       {
66646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (std::exception& e) {
66649       {
66650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66651       };
66652     } catch (...) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66655       };
66656     }
66657   }
66658   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66659   return jresult;
66660 }
66661
66662
66663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66664   void * jresult ;
66665   std::string *arg1 = 0 ;
66666   Dali::Toolkit::RadioButton result;
66667
66668   if (!jarg1) {
66669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66670     return 0;
66671   }
66672   std::string arg1_str(jarg1);
66673   arg1 = &arg1_str;
66674   {
66675     try {
66676       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66677     } catch (std::out_of_range& e) {
66678       {
66679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66680       };
66681     } catch (std::exception& e) {
66682       {
66683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66684       };
66685     } catch (...) {
66686       {
66687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66688       };
66689     }
66690   }
66691   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66692
66693   //argout typemap for const std::string&
66694
66695   return jresult;
66696 }
66697
66698
66699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66700   void * jresult ;
66701   Dali::BaseHandle arg1 ;
66702   Dali::BaseHandle *argp1 ;
66703   Dali::Toolkit::RadioButton result;
66704
66705   argp1 = (Dali::BaseHandle *)jarg1;
66706   if (!argp1) {
66707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66708     return 0;
66709   }
66710   arg1 = *argp1;
66711   {
66712     try {
66713       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (...) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66725       };
66726     }
66727   }
66728   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66729   return jresult;
66730 }
66731
66732
66733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66734   int jresult ;
66735   int result;
66736
66737   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66738   jresult = (int)result;
66739   return jresult;
66740 }
66741
66742
66743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66744   int jresult ;
66745   int result;
66746
66747   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66748   jresult = (int)result;
66749   return jresult;
66750 }
66751
66752
66753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66754   int jresult ;
66755   int result;
66756
66757   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66758   jresult = (int)result;
66759   return jresult;
66760 }
66761
66762
66763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66764   int jresult ;
66765   int result;
66766
66767   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66768   jresult = (int)result;
66769   return jresult;
66770 }
66771
66772
66773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66774   int jresult ;
66775   int result;
66776
66777   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66778   jresult = (int)result;
66779   return jresult;
66780 }
66781
66782
66783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66784   int jresult ;
66785   int result;
66786
66787   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66788   jresult = (int)result;
66789   return jresult;
66790 }
66791
66792
66793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66794   void * jresult ;
66795   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66796
66797   {
66798     try {
66799       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66800     } catch (std::out_of_range& e) {
66801       {
66802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66803       };
66804     } catch (std::exception& e) {
66805       {
66806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66807       };
66808     } catch (...) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66811       };
66812     }
66813   }
66814   jresult = (void *)result;
66815   return jresult;
66816 }
66817
66818
66819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66820   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66821
66822   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66823   {
66824     try {
66825       delete arg1;
66826     } catch (std::out_of_range& e) {
66827       {
66828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66829       };
66830     } catch (std::exception& e) {
66831       {
66832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66833       };
66834     } catch (...) {
66835       {
66836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66837       };
66838     }
66839   }
66840 }
66841
66842
66843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66844   int jresult ;
66845   int result;
66846
66847   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66848   jresult = (int)result;
66849   return jresult;
66850 }
66851
66852
66853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66854   int jresult ;
66855   int result;
66856
66857   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66858   jresult = (int)result;
66859   return jresult;
66860 }
66861
66862
66863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66864   int jresult ;
66865   int result;
66866
66867   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66868   jresult = (int)result;
66869   return jresult;
66870 }
66871
66872
66873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66874   void * jresult ;
66875   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66876
66877   {
66878     try {
66879       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66880     } catch (std::out_of_range& e) {
66881       {
66882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66883       };
66884     } catch (std::exception& e) {
66885       {
66886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (...) {
66889       {
66890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66891       };
66892     }
66893   }
66894   jresult = (void *)result;
66895   return jresult;
66896 }
66897
66898
66899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66900   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66901
66902   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66903   {
66904     try {
66905       delete arg1;
66906     } catch (std::out_of_range& e) {
66907       {
66908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66909       };
66910     } catch (std::exception& e) {
66911       {
66912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66913       };
66914     } catch (...) {
66915       {
66916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66917       };
66918     }
66919   }
66920 }
66921
66922
66923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66924   void * jresult ;
66925   Dali::Toolkit::FlexContainer *result = 0 ;
66926
66927   {
66928     try {
66929       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66930     } catch (std::out_of_range& e) {
66931       {
66932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66933       };
66934     } catch (std::exception& e) {
66935       {
66936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66937       };
66938     } catch (...) {
66939       {
66940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66941       };
66942     }
66943   }
66944   jresult = (void *)result;
66945   return jresult;
66946 }
66947
66948
66949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66950   void * jresult ;
66951   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66952   Dali::Toolkit::FlexContainer *result = 0 ;
66953
66954   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66955   if (!arg1) {
66956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66957     return 0;
66958   }
66959   {
66960     try {
66961       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66962     } catch (std::out_of_range& e) {
66963       {
66964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66965       };
66966     } catch (std::exception& e) {
66967       {
66968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66969       };
66970     } catch (...) {
66971       {
66972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66973       };
66974     }
66975   }
66976   jresult = (void *)result;
66977   return jresult;
66978 }
66979
66980
66981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66982   void * jresult ;
66983   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66984   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66985   Dali::Toolkit::FlexContainer *result = 0 ;
66986
66987   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66988   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66989   if (!arg2) {
66990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66991     return 0;
66992   }
66993   {
66994     try {
66995       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66996     } catch (std::out_of_range& e) {
66997       {
66998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66999       };
67000     } catch (std::exception& e) {
67001       {
67002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67003       };
67004     } catch (...) {
67005       {
67006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67007       };
67008     }
67009   }
67010   jresult = (void *)result;
67011   return jresult;
67012 }
67013
67014
67015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67016   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67017
67018   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67019   {
67020     try {
67021       delete arg1;
67022     } catch (std::out_of_range& e) {
67023       {
67024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67025       };
67026     } catch (std::exception& e) {
67027       {
67028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67029       };
67030     } catch (...) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67033       };
67034     }
67035   }
67036 }
67037
67038
67039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67040   void * jresult ;
67041   Dali::Toolkit::FlexContainer result;
67042
67043   {
67044     try {
67045       result = Dali::Toolkit::FlexContainer::New();
67046     } catch (std::out_of_range& e) {
67047       {
67048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67049       };
67050     } catch (std::exception& e) {
67051       {
67052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67053       };
67054     } catch (...) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67057       };
67058     }
67059   }
67060   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67061   return jresult;
67062 }
67063
67064
67065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67066   void * jresult ;
67067   Dali::BaseHandle arg1 ;
67068   Dali::BaseHandle *argp1 ;
67069   Dali::Toolkit::FlexContainer result;
67070
67071   argp1 = (Dali::BaseHandle *)jarg1;
67072   if (!argp1) {
67073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67074     return 0;
67075   }
67076   arg1 = *argp1;
67077   {
67078     try {
67079       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67080     } catch (std::out_of_range& e) {
67081       {
67082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67083       };
67084     } catch (std::exception& e) {
67085       {
67086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67087       };
67088     } catch (...) {
67089       {
67090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67091       };
67092     }
67093   }
67094   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67095   return jresult;
67096 }
67097
67098
67099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67100   int jresult ;
67101   int result;
67102
67103   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67104   jresult = (int)result;
67105   return jresult;
67106 }
67107
67108
67109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67110   int jresult ;
67111   int result;
67112
67113   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67114   jresult = (int)result;
67115   return jresult;
67116 }
67117
67118
67119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67120   int jresult ;
67121   int result;
67122
67123   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67124   jresult = (int)result;
67125   return jresult;
67126 }
67127
67128
67129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67130   int jresult ;
67131   int result;
67132
67133   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67134   jresult = (int)result;
67135   return jresult;
67136 }
67137
67138
67139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67140   void * jresult ;
67141   Dali::Toolkit::ImageView::Property *result = 0 ;
67142
67143   {
67144     try {
67145       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67146     } catch (std::out_of_range& e) {
67147       {
67148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67149       };
67150     } catch (std::exception& e) {
67151       {
67152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67153       };
67154     } catch (...) {
67155       {
67156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67157       };
67158     }
67159   }
67160   jresult = (void *)result;
67161   return jresult;
67162 }
67163
67164
67165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67166   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67167
67168   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67169   {
67170     try {
67171       delete arg1;
67172     } catch (std::out_of_range& e) {
67173       {
67174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67175       };
67176     } catch (std::exception& e) {
67177       {
67178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67179       };
67180     } catch (...) {
67181       {
67182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67183       };
67184     }
67185   }
67186 }
67187
67188
67189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67190   void * jresult ;
67191   Dali::Toolkit::ImageView *result = 0 ;
67192
67193   {
67194     try {
67195       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67196     } catch (std::out_of_range& e) {
67197       {
67198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67199       };
67200     } catch (std::exception& e) {
67201       {
67202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67203       };
67204     } catch (...) {
67205       {
67206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67207       };
67208     }
67209   }
67210   jresult = (void *)result;
67211   return jresult;
67212 }
67213
67214
67215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67216   void * jresult ;
67217   Dali::Toolkit::ImageView result;
67218
67219   {
67220     try {
67221       result = Dali::Toolkit::ImageView::New();
67222     } catch (std::out_of_range& e) {
67223       {
67224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67225       };
67226     } catch (std::exception& e) {
67227       {
67228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67229       };
67230     } catch (...) {
67231       {
67232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67233       };
67234     }
67235   }
67236   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67237   return jresult;
67238 }
67239
67240
67241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67242   void * jresult ;
67243   Dali::Image arg1 ;
67244   Dali::Image *argp1 ;
67245   Dali::Toolkit::ImageView result;
67246
67247   argp1 = (Dali::Image *)jarg1;
67248   if (!argp1) {
67249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67250     return 0;
67251   }
67252   arg1 = *argp1;
67253   {
67254     try {
67255       result = Dali::Toolkit::ImageView::New(arg1);
67256     } catch (std::out_of_range& e) {
67257       {
67258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67259       };
67260     } catch (std::exception& e) {
67261       {
67262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67267       };
67268     }
67269   }
67270   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67271   return jresult;
67272 }
67273
67274
67275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67276   void * jresult ;
67277   std::string *arg1 = 0 ;
67278   Dali::Toolkit::ImageView result;
67279
67280   if (!jarg1) {
67281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67282     return 0;
67283   }
67284   std::string arg1_str(jarg1);
67285   arg1 = &arg1_str;
67286   {
67287     try {
67288       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67289     } catch (std::out_of_range& e) {
67290       {
67291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67292       };
67293     } catch (std::exception& e) {
67294       {
67295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67296       };
67297     } catch (...) {
67298       {
67299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67300       };
67301     }
67302   }
67303   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67304
67305   //argout typemap for const std::string&
67306
67307   return jresult;
67308 }
67309
67310
67311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67312   void * jresult ;
67313   std::string *arg1 = 0 ;
67314   Dali::ImageDimensions arg2 ;
67315   Dali::ImageDimensions *argp2 ;
67316   Dali::Toolkit::ImageView result;
67317
67318   if (!jarg1) {
67319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67320     return 0;
67321   }
67322   std::string arg1_str(jarg1);
67323   arg1 = &arg1_str;
67324   argp2 = (Dali::ImageDimensions *)jarg2;
67325   if (!argp2) {
67326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67327     return 0;
67328   }
67329   arg2 = *argp2;
67330   {
67331     try {
67332       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67333     } catch (std::out_of_range& e) {
67334       {
67335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67336       };
67337     } catch (std::exception& e) {
67338       {
67339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67340       };
67341     } catch (...) {
67342       {
67343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67344       };
67345     }
67346   }
67347   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67348
67349   //argout typemap for const std::string&
67350
67351   return jresult;
67352 }
67353
67354
67355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67356   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67357
67358   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67359   {
67360     try {
67361       delete arg1;
67362     } catch (std::out_of_range& e) {
67363       {
67364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67365       };
67366     } catch (std::exception& e) {
67367       {
67368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67369       };
67370     } catch (...) {
67371       {
67372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67373       };
67374     }
67375   }
67376 }
67377
67378
67379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67380   void * jresult ;
67381   Dali::Toolkit::ImageView *arg1 = 0 ;
67382   Dali::Toolkit::ImageView *result = 0 ;
67383
67384   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67385   if (!arg1) {
67386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67387     return 0;
67388   }
67389   {
67390     try {
67391       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67403       };
67404     }
67405   }
67406   jresult = (void *)result;
67407   return jresult;
67408 }
67409
67410
67411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67412   void * jresult ;
67413   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67414   Dali::Toolkit::ImageView *arg2 = 0 ;
67415   Dali::Toolkit::ImageView *result = 0 ;
67416
67417   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67418   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67419   if (!arg2) {
67420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67421     return 0;
67422   }
67423   {
67424     try {
67425       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67426     } catch (std::out_of_range& e) {
67427       {
67428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (std::exception& e) {
67431       {
67432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67437       };
67438     }
67439   }
67440   jresult = (void *)result;
67441   return jresult;
67442 }
67443
67444
67445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67446   void * jresult ;
67447   Dali::BaseHandle arg1 ;
67448   Dali::BaseHandle *argp1 ;
67449   Dali::Toolkit::ImageView result;
67450
67451   argp1 = (Dali::BaseHandle *)jarg1;
67452   if (!argp1) {
67453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67454     return 0;
67455   }
67456   arg1 = *argp1;
67457   {
67458     try {
67459       result = Dali::Toolkit::ImageView::DownCast(arg1);
67460     } catch (std::out_of_range& e) {
67461       {
67462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67463       };
67464     } catch (std::exception& e) {
67465       {
67466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67467       };
67468     } catch (...) {
67469       {
67470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67471       };
67472     }
67473   }
67474   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67475   return jresult;
67476 }
67477
67478
67479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67480   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67481   Dali::Image arg2 ;
67482   Dali::Image *argp2 ;
67483
67484   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67485   argp2 = (Dali::Image *)jarg2;
67486   if (!argp2) {
67487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67488     return ;
67489   }
67490   arg2 = *argp2;
67491   {
67492     try {
67493       (arg1)->SetImage(arg2);
67494     } catch (std::out_of_range& e) {
67495       {
67496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67497       };
67498     } catch (std::exception& e) {
67499       {
67500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67501       };
67502     } catch (...) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67505       };
67506     }
67507   }
67508 }
67509
67510
67511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67512   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67513   std::string *arg2 = 0 ;
67514
67515   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67516   if (!jarg2) {
67517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67518     return ;
67519   }
67520   std::string arg2_str(jarg2);
67521   arg2 = &arg2_str;
67522   {
67523     try {
67524       (arg1)->SetImage((std::string const &)*arg2);
67525     } catch (std::out_of_range& e) {
67526       {
67527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67528       };
67529     } catch (std::exception& e) {
67530       {
67531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67532       };
67533     } catch (...) {
67534       {
67535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67536       };
67537     }
67538   }
67539
67540   //argout typemap for const std::string&
67541
67542 }
67543
67544
67545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67546   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67547   std::string *arg2 = 0 ;
67548   Dali::ImageDimensions arg3 ;
67549   Dali::ImageDimensions *argp3 ;
67550
67551   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67552   if (!jarg2) {
67553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67554     return ;
67555   }
67556   std::string arg2_str(jarg2);
67557   arg2 = &arg2_str;
67558   argp3 = (Dali::ImageDimensions *)jarg3;
67559   if (!argp3) {
67560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67561     return ;
67562   }
67563   arg3 = *argp3;
67564   {
67565     try {
67566       (arg1)->SetImage((std::string const &)*arg2,arg3);
67567     } catch (std::out_of_range& e) {
67568       {
67569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67570       };
67571     } catch (std::exception& e) {
67572       {
67573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67574       };
67575     } catch (...) {
67576       {
67577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67578       };
67579     }
67580   }
67581
67582   //argout typemap for const std::string&
67583
67584 }
67585
67586
67587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67588   void * jresult ;
67589   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67590   Dali::Image result;
67591
67592   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67593   {
67594     try {
67595       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67596     } catch (std::out_of_range& e) {
67597       {
67598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67599       };
67600     } catch (std::exception& e) {
67601       {
67602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (...) {
67605       {
67606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67607       };
67608     }
67609   }
67610   jresult = new Dali::Image((const Dali::Image &)result);
67611   return jresult;
67612 }
67613
67614
67615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67616   int jresult ;
67617   int result;
67618
67619   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67620   jresult = (int)result;
67621   return jresult;
67622 }
67623
67624
67625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67626   int jresult ;
67627   int result;
67628
67629   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67630   jresult = (int)result;
67631   return jresult;
67632 }
67633
67634
67635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67636   int jresult ;
67637   int result;
67638
67639   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67640   jresult = (int)result;
67641   return jresult;
67642 }
67643
67644
67645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67646   int jresult ;
67647   int result;
67648
67649   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67650   jresult = (int)result;
67651   return jresult;
67652 }
67653
67654
67655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67656   int jresult ;
67657   int result;
67658
67659   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67660   jresult = (int)result;
67661   return jresult;
67662 }
67663
67664
67665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67666   int jresult ;
67667   int result;
67668
67669   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67670   jresult = (int)result;
67671   return jresult;
67672 }
67673
67674
67675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67676   int jresult ;
67677   int result;
67678
67679   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67680   jresult = (int)result;
67681   return jresult;
67682 }
67683
67684
67685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67686   int jresult ;
67687   int result;
67688
67689   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67690   jresult = (int)result;
67691   return jresult;
67692 }
67693
67694
67695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67696   void * jresult ;
67697   Dali::Toolkit::Model3dView::Property *result = 0 ;
67698
67699   {
67700     try {
67701       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67702     } catch (std::out_of_range& e) {
67703       {
67704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (std::exception& e) {
67707       {
67708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (...) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67713       };
67714     }
67715   }
67716   jresult = (void *)result;
67717   return jresult;
67718 }
67719
67720
67721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67722   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67723
67724   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67725   {
67726     try {
67727       delete arg1;
67728     } catch (std::out_of_range& e) {
67729       {
67730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67731       };
67732     } catch (std::exception& e) {
67733       {
67734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67735       };
67736     } catch (...) {
67737       {
67738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67739       };
67740     }
67741   }
67742 }
67743
67744
67745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67746   void * jresult ;
67747   Dali::Toolkit::Model3dView result;
67748
67749   {
67750     try {
67751       result = Dali::Toolkit::Model3dView::New();
67752     } catch (std::out_of_range& e) {
67753       {
67754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67755       };
67756     } catch (std::exception& e) {
67757       {
67758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67759       };
67760     } catch (...) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67763       };
67764     }
67765   }
67766   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67767   return jresult;
67768 }
67769
67770
67771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67772   void * jresult ;
67773   std::string *arg1 = 0 ;
67774   std::string *arg2 = 0 ;
67775   std::string *arg3 = 0 ;
67776   Dali::Toolkit::Model3dView result;
67777
67778   if (!jarg1) {
67779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67780     return 0;
67781   }
67782   std::string arg1_str(jarg1);
67783   arg1 = &arg1_str;
67784   if (!jarg2) {
67785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67786     return 0;
67787   }
67788   std::string arg2_str(jarg2);
67789   arg2 = &arg2_str;
67790   if (!jarg3) {
67791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67792     return 0;
67793   }
67794   std::string arg3_str(jarg3);
67795   arg3 = &arg3_str;
67796   {
67797     try {
67798       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67799     } catch (std::out_of_range& e) {
67800       {
67801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67802       };
67803     } catch (std::exception& e) {
67804       {
67805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67806       };
67807     } catch (...) {
67808       {
67809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67810       };
67811     }
67812   }
67813   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67814
67815   //argout typemap for const std::string&
67816
67817
67818   //argout typemap for const std::string&
67819
67820
67821   //argout typemap for const std::string&
67822
67823   return jresult;
67824 }
67825
67826
67827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67828   void * jresult ;
67829   Dali::Toolkit::Model3dView *result = 0 ;
67830
67831   {
67832     try {
67833       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67834     } catch (std::out_of_range& e) {
67835       {
67836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (std::exception& e) {
67839       {
67840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67841       };
67842     } catch (...) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67845       };
67846     }
67847   }
67848   jresult = (void *)result;
67849   return jresult;
67850 }
67851
67852
67853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67854   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67855
67856   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67857   {
67858     try {
67859       delete arg1;
67860     } catch (std::out_of_range& e) {
67861       {
67862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67863       };
67864     } catch (std::exception& e) {
67865       {
67866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67867       };
67868     } catch (...) {
67869       {
67870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67871       };
67872     }
67873   }
67874 }
67875
67876
67877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67878   void * jresult ;
67879   Dali::Toolkit::Model3dView *arg1 = 0 ;
67880   Dali::Toolkit::Model3dView *result = 0 ;
67881
67882   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67883   if (!arg1) {
67884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67885     return 0;
67886   }
67887   {
67888     try {
67889       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67901       };
67902     }
67903   }
67904   jresult = (void *)result;
67905   return jresult;
67906 }
67907
67908
67909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67910   void * jresult ;
67911   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67912   Dali::Toolkit::Model3dView *arg2 = 0 ;
67913   Dali::Toolkit::Model3dView *result = 0 ;
67914
67915   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67916   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67917   if (!arg2) {
67918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67919     return 0;
67920   }
67921   {
67922     try {
67923       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67924     } catch (std::out_of_range& e) {
67925       {
67926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67927       };
67928     } catch (std::exception& e) {
67929       {
67930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67931       };
67932     } catch (...) {
67933       {
67934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67935       };
67936     }
67937   }
67938   jresult = (void *)result;
67939   return jresult;
67940 }
67941
67942
67943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67944   void * jresult ;
67945   Dali::BaseHandle arg1 ;
67946   Dali::BaseHandle *argp1 ;
67947   Dali::Toolkit::Model3dView result;
67948
67949   argp1 = (Dali::BaseHandle *)jarg1;
67950   if (!argp1) {
67951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67952     return 0;
67953   }
67954   arg1 = *argp1;
67955   {
67956     try {
67957       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (...) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67969       };
67970     }
67971   }
67972   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67973   return jresult;
67974 }
67975
67976
67977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67978   int jresult ;
67979   int result;
67980
67981   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67982   jresult = (int)result;
67983   return jresult;
67984 }
67985
67986
67987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67988   int jresult ;
67989   int result;
67990
67991   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67992   jresult = (int)result;
67993   return jresult;
67994 }
67995
67996
67997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67998   int jresult ;
67999   int result;
68000
68001   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68002   jresult = (int)result;
68003   return jresult;
68004 }
68005
68006
68007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68008   int jresult ;
68009   int result;
68010
68011   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68012   jresult = (int)result;
68013   return jresult;
68014 }
68015
68016
68017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68018   int jresult ;
68019   int result;
68020
68021   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68022   jresult = (int)result;
68023   return jresult;
68024 }
68025
68026
68027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68028   int jresult ;
68029   int result;
68030
68031   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68032   jresult = (int)result;
68033   return jresult;
68034 }
68035
68036
68037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68038   int jresult ;
68039   int result;
68040
68041   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68042   jresult = (int)result;
68043   return jresult;
68044 }
68045
68046
68047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68048   int jresult ;
68049   int result;
68050
68051   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68052   jresult = (int)result;
68053   return jresult;
68054 }
68055
68056
68057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68058   int jresult ;
68059   int result;
68060
68061   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68062   jresult = (int)result;
68063   return jresult;
68064 }
68065
68066
68067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68068   void * jresult ;
68069   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68070
68071   {
68072     try {
68073       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68074     } catch (std::out_of_range& e) {
68075       {
68076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68077       };
68078     } catch (std::exception& e) {
68079       {
68080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (...) {
68083       {
68084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68085       };
68086     }
68087   }
68088   jresult = (void *)result;
68089   return jresult;
68090 }
68091
68092
68093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68094   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68095
68096   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68097   {
68098     try {
68099       delete arg1;
68100     } catch (std::out_of_range& e) {
68101       {
68102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68103       };
68104     } catch (std::exception& e) {
68105       {
68106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68111       };
68112     }
68113   }
68114 }
68115
68116
68117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68118   void * jresult ;
68119   Dali::Toolkit::ScrollBar *result = 0 ;
68120
68121   {
68122     try {
68123       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68124     } catch (std::out_of_range& e) {
68125       {
68126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68127       };
68128     } catch (std::exception& e) {
68129       {
68130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68131       };
68132     } catch (...) {
68133       {
68134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68135       };
68136     }
68137   }
68138   jresult = (void *)result;
68139   return jresult;
68140 }
68141
68142
68143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68144   void * jresult ;
68145   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68146   Dali::Toolkit::ScrollBar *result = 0 ;
68147
68148   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68149   if (!arg1) {
68150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68151     return 0;
68152   }
68153   {
68154     try {
68155       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68156     } catch (std::out_of_range& e) {
68157       {
68158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68159       };
68160     } catch (std::exception& e) {
68161       {
68162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68163       };
68164     } catch (...) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68167       };
68168     }
68169   }
68170   jresult = (void *)result;
68171   return jresult;
68172 }
68173
68174
68175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68176   void * jresult ;
68177   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68178   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68179   Dali::Toolkit::ScrollBar *result = 0 ;
68180
68181   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68182   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68183   if (!arg2) {
68184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68185     return 0;
68186   }
68187   {
68188     try {
68189       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68190     } catch (std::out_of_range& e) {
68191       {
68192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68193       };
68194     } catch (std::exception& e) {
68195       {
68196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68197       };
68198     } catch (...) {
68199       {
68200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68201       };
68202     }
68203   }
68204   jresult = (void *)result;
68205   return jresult;
68206 }
68207
68208
68209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68210   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68211
68212   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68213   {
68214     try {
68215       delete arg1;
68216     } catch (std::out_of_range& e) {
68217       {
68218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68219       };
68220     } catch (std::exception& e) {
68221       {
68222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68223       };
68224     } catch (...) {
68225       {
68226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68227       };
68228     }
68229   }
68230 }
68231
68232
68233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68234   void * jresult ;
68235   Dali::Toolkit::ScrollBar::Direction arg1 ;
68236   Dali::Toolkit::ScrollBar result;
68237
68238   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68239   {
68240     try {
68241       result = Dali::Toolkit::ScrollBar::New(arg1);
68242     } catch (std::out_of_range& e) {
68243       {
68244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68245       };
68246     } catch (std::exception& e) {
68247       {
68248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68249       };
68250     } catch (...) {
68251       {
68252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68253       };
68254     }
68255   }
68256   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68257   return jresult;
68258 }
68259
68260
68261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68262   void * jresult ;
68263   Dali::Toolkit::ScrollBar result;
68264
68265   {
68266     try {
68267       result = Dali::Toolkit::ScrollBar::New();
68268     } catch (std::out_of_range& e) {
68269       {
68270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68271       };
68272     } catch (std::exception& e) {
68273       {
68274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68275       };
68276     } catch (...) {
68277       {
68278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68279       };
68280     }
68281   }
68282   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68283   return jresult;
68284 }
68285
68286
68287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68288   void * jresult ;
68289   Dali::BaseHandle arg1 ;
68290   Dali::BaseHandle *argp1 ;
68291   Dali::Toolkit::ScrollBar result;
68292
68293   argp1 = (Dali::BaseHandle *)jarg1;
68294   if (!argp1) {
68295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68296     return 0;
68297   }
68298   arg1 = *argp1;
68299   {
68300     try {
68301       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68302     } catch (std::out_of_range& e) {
68303       {
68304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68305       };
68306     } catch (std::exception& e) {
68307       {
68308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68309       };
68310     } catch (...) {
68311       {
68312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68313       };
68314     }
68315   }
68316   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68322   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68323   Dali::Handle arg2 ;
68324   Dali::Property::Index arg3 ;
68325   Dali::Property::Index arg4 ;
68326   Dali::Property::Index arg5 ;
68327   Dali::Property::Index arg6 ;
68328   Dali::Handle *argp2 ;
68329
68330   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68331   argp2 = (Dali::Handle *)jarg2;
68332   if (!argp2) {
68333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68334     return ;
68335   }
68336   arg2 = *argp2;
68337   arg3 = (Dali::Property::Index)jarg3;
68338   arg4 = (Dali::Property::Index)jarg4;
68339   arg5 = (Dali::Property::Index)jarg5;
68340   arg6 = (Dali::Property::Index)jarg6;
68341   {
68342     try {
68343       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68344     } catch (std::out_of_range& e) {
68345       {
68346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68347       };
68348     } catch (std::exception& e) {
68349       {
68350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68351       };
68352     } catch (...) {
68353       {
68354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68355       };
68356     }
68357   }
68358 }
68359
68360
68361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68362   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68363   Dali::Actor arg2 ;
68364   Dali::Actor *argp2 ;
68365
68366   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68367   argp2 = (Dali::Actor *)jarg2;
68368   if (!argp2) {
68369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68370     return ;
68371   }
68372   arg2 = *argp2;
68373   {
68374     try {
68375       (arg1)->SetScrollIndicator(arg2);
68376     } catch (std::out_of_range& e) {
68377       {
68378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68379       };
68380     } catch (std::exception& e) {
68381       {
68382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68383       };
68384     } catch (...) {
68385       {
68386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68387       };
68388     }
68389   }
68390 }
68391
68392
68393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68394   void * jresult ;
68395   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68396   Dali::Actor result;
68397
68398   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68399   {
68400     try {
68401       result = (arg1)->GetScrollIndicator();
68402     } catch (std::out_of_range& e) {
68403       {
68404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68405       };
68406     } catch (std::exception& e) {
68407       {
68408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (...) {
68411       {
68412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68413       };
68414     }
68415   }
68416   jresult = new Dali::Actor((const Dali::Actor &)result);
68417   return jresult;
68418 }
68419
68420
68421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68422   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68423   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68424
68425   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68426   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68427   if (!arg2) {
68428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68429     return ;
68430   }
68431   {
68432     try {
68433       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68434     } catch (std::out_of_range& e) {
68435       {
68436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68437       };
68438     } catch (std::exception& e) {
68439       {
68440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68441       };
68442     } catch (...) {
68443       {
68444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68445       };
68446     }
68447   }
68448 }
68449
68450
68451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68452   void * jresult ;
68453   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68454   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68455
68456   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68457   {
68458     try {
68459       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68460     } catch (std::out_of_range& e) {
68461       {
68462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68463       };
68464     } catch (std::exception& e) {
68465       {
68466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68467       };
68468     } catch (...) {
68469       {
68470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68471       };
68472     }
68473   }
68474   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68475   return jresult;
68476 }
68477
68478
68479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68480   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68481   Dali::Toolkit::ScrollBar::Direction arg2 ;
68482
68483   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68484   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68485   {
68486     try {
68487       (arg1)->SetScrollDirection(arg2);
68488     } catch (std::out_of_range& e) {
68489       {
68490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68491       };
68492     } catch (std::exception& e) {
68493       {
68494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68495       };
68496     } catch (...) {
68497       {
68498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68499       };
68500     }
68501   }
68502 }
68503
68504
68505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68506   int jresult ;
68507   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68508   Dali::Toolkit::ScrollBar::Direction result;
68509
68510   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68511   {
68512     try {
68513       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68514     } catch (std::out_of_range& e) {
68515       {
68516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68517       };
68518     } catch (std::exception& e) {
68519       {
68520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68521       };
68522     } catch (...) {
68523       {
68524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68525       };
68526     }
68527   }
68528   jresult = (int)result;
68529   return jresult;
68530 }
68531
68532
68533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68534   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68535   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68536
68537   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68538   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68539   {
68540     try {
68541       (arg1)->SetIndicatorHeightPolicy(arg2);
68542     } catch (std::out_of_range& e) {
68543       {
68544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68545       };
68546     } catch (std::exception& e) {
68547       {
68548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68549       };
68550     } catch (...) {
68551       {
68552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68553       };
68554     }
68555   }
68556 }
68557
68558
68559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68560   int jresult ;
68561   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68562   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68563
68564   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68565   {
68566     try {
68567       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68568     } catch (std::out_of_range& e) {
68569       {
68570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (std::exception& e) {
68573       {
68574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68575       };
68576     } catch (...) {
68577       {
68578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68579       };
68580     }
68581   }
68582   jresult = (int)result;
68583   return jresult;
68584 }
68585
68586
68587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68588   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68589   float arg2 ;
68590
68591   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68592   arg2 = (float)jarg2;
68593   {
68594     try {
68595       (arg1)->SetIndicatorFixedHeight(arg2);
68596     } catch (std::out_of_range& e) {
68597       {
68598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68599       };
68600     } catch (std::exception& e) {
68601       {
68602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68603       };
68604     } catch (...) {
68605       {
68606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68607       };
68608     }
68609   }
68610 }
68611
68612
68613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68614   float jresult ;
68615   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68616   float result;
68617
68618   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68619   {
68620     try {
68621       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68622     } catch (std::out_of_range& e) {
68623       {
68624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68625       };
68626     } catch (std::exception& e) {
68627       {
68628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68629       };
68630     } catch (...) {
68631       {
68632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68633       };
68634     }
68635   }
68636   jresult = result;
68637   return jresult;
68638 }
68639
68640
68641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68642   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68643   float arg2 ;
68644
68645   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68646   arg2 = (float)jarg2;
68647   {
68648     try {
68649       (arg1)->SetIndicatorShowDuration(arg2);
68650     } catch (std::out_of_range& e) {
68651       {
68652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68653       };
68654     } catch (std::exception& e) {
68655       {
68656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68657       };
68658     } catch (...) {
68659       {
68660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68661       };
68662     }
68663   }
68664 }
68665
68666
68667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68668   float jresult ;
68669   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68670   float result;
68671
68672   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68673   {
68674     try {
68675       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68676     } catch (std::out_of_range& e) {
68677       {
68678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68679       };
68680     } catch (std::exception& e) {
68681       {
68682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68683       };
68684     } catch (...) {
68685       {
68686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68687       };
68688     }
68689   }
68690   jresult = result;
68691   return jresult;
68692 }
68693
68694
68695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68696   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68697   float arg2 ;
68698
68699   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68700   arg2 = (float)jarg2;
68701   {
68702     try {
68703       (arg1)->SetIndicatorHideDuration(arg2);
68704     } catch (std::out_of_range& e) {
68705       {
68706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68707       };
68708     } catch (std::exception& e) {
68709       {
68710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68711       };
68712     } catch (...) {
68713       {
68714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68715       };
68716     }
68717   }
68718 }
68719
68720
68721 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68722   float jresult ;
68723   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68724   float result;
68725
68726   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68727   {
68728     try {
68729       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68730     } catch (std::out_of_range& e) {
68731       {
68732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68733       };
68734     } catch (std::exception& e) {
68735       {
68736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68737       };
68738     } catch (...) {
68739       {
68740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68741       };
68742     }
68743   }
68744   jresult = result;
68745   return jresult;
68746 }
68747
68748
68749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68750   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68751
68752   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68753   {
68754     try {
68755       (arg1)->ShowIndicator();
68756     } catch (std::out_of_range& e) {
68757       {
68758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68759       };
68760     } catch (std::exception& e) {
68761       {
68762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68763       };
68764     } catch (...) {
68765       {
68766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68767       };
68768     }
68769   }
68770 }
68771
68772
68773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68774   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68775
68776   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68777   {
68778     try {
68779       (arg1)->HideIndicator();
68780     } catch (std::out_of_range& e) {
68781       {
68782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68783       };
68784     } catch (std::exception& e) {
68785       {
68786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68787       };
68788     } catch (...) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68791       };
68792     }
68793   }
68794 }
68795
68796
68797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68798   void * jresult ;
68799   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68800   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68801
68802   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68803   {
68804     try {
68805       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68806     } catch (std::out_of_range& e) {
68807       {
68808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (std::exception& e) {
68811       {
68812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68817       };
68818     }
68819   }
68820   jresult = (void *)result;
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68826   void * jresult ;
68827   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68828   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68829
68830   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68831   {
68832     try {
68833       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68834     } catch (std::out_of_range& e) {
68835       {
68836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68837       };
68838     } catch (std::exception& e) {
68839       {
68840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68841       };
68842     } catch (...) {
68843       {
68844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68845       };
68846     }
68847   }
68848   jresult = (void *)result;
68849   return jresult;
68850 }
68851
68852
68853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68854   int jresult ;
68855   int result;
68856
68857   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68858   jresult = (int)result;
68859   return jresult;
68860 }
68861
68862
68863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68864   int jresult ;
68865   int result;
68866
68867   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68868   jresult = (int)result;
68869   return jresult;
68870 }
68871
68872
68873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68874   int jresult ;
68875   int result;
68876
68877   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68878   jresult = (int)result;
68879   return jresult;
68880 }
68881
68882
68883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68884   int jresult ;
68885   int result;
68886
68887   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68888   jresult = (int)result;
68889   return jresult;
68890 }
68891
68892
68893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68894   int jresult ;
68895   int result;
68896
68897   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68898   jresult = (int)result;
68899   return jresult;
68900 }
68901
68902
68903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68904   int jresult ;
68905   int result;
68906
68907   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68908   jresult = (int)result;
68909   return jresult;
68910 }
68911
68912
68913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68914   int jresult ;
68915   int result;
68916
68917   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68918   jresult = (int)result;
68919   return jresult;
68920 }
68921
68922
68923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68924   int jresult ;
68925   int result;
68926
68927   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68928   jresult = (int)result;
68929   return jresult;
68930 }
68931
68932
68933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68934   int jresult ;
68935   int result;
68936
68937   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68938   jresult = (int)result;
68939   return jresult;
68940 }
68941
68942
68943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68944   int jresult ;
68945   int result;
68946
68947   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68948   jresult = (int)result;
68949   return jresult;
68950 }
68951
68952
68953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68954   int jresult ;
68955   int result;
68956
68957   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68958   jresult = (int)result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68964   int jresult ;
68965   int result;
68966
68967   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68968   jresult = (int)result;
68969   return jresult;
68970 }
68971
68972
68973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68974   int jresult ;
68975   int result;
68976
68977   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68978   jresult = (int)result;
68979   return jresult;
68980 }
68981
68982
68983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68984   int jresult ;
68985   int result;
68986
68987   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68988   jresult = (int)result;
68989   return jresult;
68990 }
68991
68992
68993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68994   void * jresult ;
68995   Dali::Toolkit::Scrollable::Property *result = 0 ;
68996
68997   {
68998     try {
68999       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69000     } catch (std::out_of_range& e) {
69001       {
69002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69003       };
69004     } catch (std::exception& e) {
69005       {
69006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69007       };
69008     } catch (...) {
69009       {
69010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69011       };
69012     }
69013   }
69014   jresult = (void *)result;
69015   return jresult;
69016 }
69017
69018
69019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
69020   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69021
69022   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
69023   {
69024     try {
69025       delete arg1;
69026     } catch (std::out_of_range& e) {
69027       {
69028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69029       };
69030     } catch (std::exception& e) {
69031       {
69032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69033       };
69034     } catch (...) {
69035       {
69036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69037       };
69038     }
69039   }
69040 }
69041
69042
69043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
69044   void * jresult ;
69045   Dali::Toolkit::Scrollable *result = 0 ;
69046
69047   {
69048     try {
69049       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69050     } catch (std::out_of_range& e) {
69051       {
69052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (std::exception& e) {
69055       {
69056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69057       };
69058     } catch (...) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69061       };
69062     }
69063   }
69064   jresult = (void *)result;
69065   return jresult;
69066 }
69067
69068
69069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69070   void * jresult ;
69071   Dali::Toolkit::Scrollable *arg1 = 0 ;
69072   Dali::Toolkit::Scrollable *result = 0 ;
69073
69074   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69075   if (!arg1) {
69076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69077     return 0;
69078   }
69079   {
69080     try {
69081       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69082     } catch (std::out_of_range& e) {
69083       {
69084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69085       };
69086     } catch (std::exception& e) {
69087       {
69088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69089       };
69090     } catch (...) {
69091       {
69092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69093       };
69094     }
69095   }
69096   jresult = (void *)result;
69097   return jresult;
69098 }
69099
69100
69101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69102   void * jresult ;
69103   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69104   Dali::Toolkit::Scrollable *arg2 = 0 ;
69105   Dali::Toolkit::Scrollable *result = 0 ;
69106
69107   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69108   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69109   if (!arg2) {
69110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69111     return 0;
69112   }
69113   {
69114     try {
69115       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69116     } catch (std::out_of_range& e) {
69117       {
69118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69119       };
69120     } catch (std::exception& e) {
69121       {
69122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69123       };
69124     } catch (...) {
69125       {
69126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69127       };
69128     }
69129   }
69130   jresult = (void *)result;
69131   return jresult;
69132 }
69133
69134
69135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69136   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69137
69138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69139   {
69140     try {
69141       delete arg1;
69142     } catch (std::out_of_range& e) {
69143       {
69144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69145       };
69146     } catch (std::exception& e) {
69147       {
69148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69149       };
69150     } catch (...) {
69151       {
69152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69153       };
69154     }
69155   }
69156 }
69157
69158
69159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69160   void * jresult ;
69161   Dali::BaseHandle arg1 ;
69162   Dali::BaseHandle *argp1 ;
69163   Dali::Toolkit::Scrollable result;
69164
69165   argp1 = (Dali::BaseHandle *)jarg1;
69166   if (!argp1) {
69167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69168     return 0;
69169   }
69170   arg1 = *argp1;
69171   {
69172     try {
69173       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69174     } catch (std::out_of_range& e) {
69175       {
69176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69177       };
69178     } catch (std::exception& e) {
69179       {
69180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69181       };
69182     } catch (...) {
69183       {
69184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69185       };
69186     }
69187   }
69188   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69189   return jresult;
69190 }
69191
69192
69193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69194   unsigned int jresult ;
69195   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69196   bool result;
69197
69198   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69199   {
69200     try {
69201       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69202     } catch (std::out_of_range& e) {
69203       {
69204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (std::exception& e) {
69207       {
69208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69209       };
69210     } catch (...) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69213       };
69214     }
69215   }
69216   jresult = result;
69217   return jresult;
69218 }
69219
69220
69221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69222   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69223   bool arg2 ;
69224
69225   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69226   arg2 = jarg2 ? true : false;
69227   {
69228     try {
69229       (arg1)->SetOvershootEnabled(arg2);
69230     } catch (std::out_of_range& e) {
69231       {
69232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69233       };
69234     } catch (std::exception& e) {
69235       {
69236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69237       };
69238     } catch (...) {
69239       {
69240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69241       };
69242     }
69243   }
69244 }
69245
69246
69247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69249   Dali::Vector4 *arg2 = 0 ;
69250
69251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69252   arg2 = (Dali::Vector4 *)jarg2;
69253   if (!arg2) {
69254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69255     return ;
69256   }
69257   {
69258     try {
69259       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69260     } catch (std::out_of_range& e) {
69261       {
69262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69263       };
69264     } catch (std::exception& e) {
69265       {
69266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69267       };
69268     } catch (...) {
69269       {
69270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69271       };
69272     }
69273   }
69274 }
69275
69276
69277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69278   void * jresult ;
69279   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69280   Dali::Vector4 result;
69281
69282   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69283   {
69284     try {
69285       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69286     } catch (std::out_of_range& e) {
69287       {
69288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69289       };
69290     } catch (std::exception& e) {
69291       {
69292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69293       };
69294     } catch (...) {
69295       {
69296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69297       };
69298     }
69299   }
69300   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69301   return jresult;
69302 }
69303
69304
69305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69306   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69307   float arg2 ;
69308
69309   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69310   arg2 = (float)jarg2;
69311   {
69312     try {
69313       (arg1)->SetOvershootAnimationSpeed(arg2);
69314     } catch (std::out_of_range& e) {
69315       {
69316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69317       };
69318     } catch (std::exception& e) {
69319       {
69320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69321       };
69322     } catch (...) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69325       };
69326     }
69327   }
69328 }
69329
69330
69331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69332   float jresult ;
69333   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69334   float result;
69335
69336   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69337   {
69338     try {
69339       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69340     } catch (std::out_of_range& e) {
69341       {
69342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69343       };
69344     } catch (std::exception& e) {
69345       {
69346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69347       };
69348     } catch (...) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69351       };
69352     }
69353   }
69354   jresult = result;
69355   return jresult;
69356 }
69357
69358
69359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69360   void * jresult ;
69361   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69362   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69363
69364   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69365   {
69366     try {
69367       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69368     } catch (std::out_of_range& e) {
69369       {
69370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69371       };
69372     } catch (std::exception& e) {
69373       {
69374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69375       };
69376     } catch (...) {
69377       {
69378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69379       };
69380     }
69381   }
69382   jresult = (void *)result;
69383   return jresult;
69384 }
69385
69386
69387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69388   void * jresult ;
69389   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69390   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69391
69392   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69393   {
69394     try {
69395       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69396     } catch (std::out_of_range& e) {
69397       {
69398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69399       };
69400     } catch (std::exception& e) {
69401       {
69402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (...) {
69405       {
69406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69407       };
69408     }
69409   }
69410   jresult = (void *)result;
69411   return jresult;
69412 }
69413
69414
69415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69416   void * jresult ;
69417   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69418   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69419
69420   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69421   {
69422     try {
69423       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69424     } catch (std::out_of_range& e) {
69425       {
69426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69427       };
69428     } catch (std::exception& e) {
69429       {
69430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69435       };
69436     }
69437   }
69438   jresult = (void *)result;
69439   return jresult;
69440 }
69441
69442
69443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69444   unsigned int jresult ;
69445   Dali::Toolkit::ControlOrientation::Type arg1 ;
69446   bool result;
69447
69448   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69449   {
69450     try {
69451       result = (bool)Dali::Toolkit::IsVertical(arg1);
69452     } catch (std::out_of_range& e) {
69453       {
69454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (std::exception& e) {
69457       {
69458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69459       };
69460     } catch (...) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69463       };
69464     }
69465   }
69466   jresult = result;
69467   return jresult;
69468 }
69469
69470
69471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69472   unsigned int jresult ;
69473   Dali::Toolkit::ControlOrientation::Type arg1 ;
69474   bool result;
69475
69476   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69477   {
69478     try {
69479       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69480     } catch (std::out_of_range& e) {
69481       {
69482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69483       };
69484     } catch (std::exception& e) {
69485       {
69486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69487       };
69488     } catch (...) {
69489       {
69490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69491       };
69492     }
69493   }
69494   jresult = result;
69495   return jresult;
69496 }
69497
69498
69499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69500   void * jresult ;
69501   unsigned int arg1 ;
69502   unsigned int arg2 ;
69503   Dali::Toolkit::ItemRange *result = 0 ;
69504
69505   arg1 = (unsigned int)jarg1;
69506   arg2 = (unsigned int)jarg2;
69507   {
69508     try {
69509       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69510     } catch (std::out_of_range& e) {
69511       {
69512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69513       };
69514     } catch (std::exception& e) {
69515       {
69516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (...) {
69519       {
69520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69521       };
69522     }
69523   }
69524   jresult = (void *)result;
69525   return jresult;
69526 }
69527
69528
69529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69530   void * jresult ;
69531   Dali::Toolkit::ItemRange *arg1 = 0 ;
69532   Dali::Toolkit::ItemRange *result = 0 ;
69533
69534   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69535   if (!arg1) {
69536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69537     return 0;
69538   }
69539   {
69540     try {
69541       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69542     } catch (std::out_of_range& e) {
69543       {
69544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69545       };
69546     } catch (std::exception& e) {
69547       {
69548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69549       };
69550     } catch (...) {
69551       {
69552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69553       };
69554     }
69555   }
69556   jresult = (void *)result;
69557   return jresult;
69558 }
69559
69560
69561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69562   void * jresult ;
69563   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69564   Dali::Toolkit::ItemRange *arg2 = 0 ;
69565   Dali::Toolkit::ItemRange *result = 0 ;
69566
69567   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69568   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69569   if (!arg2) {
69570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69571     return 0;
69572   }
69573   {
69574     try {
69575       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69576     } catch (std::out_of_range& e) {
69577       {
69578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69579       };
69580     } catch (std::exception& e) {
69581       {
69582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69583       };
69584     } catch (...) {
69585       {
69586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69587       };
69588     }
69589   }
69590   jresult = (void *)result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69596   unsigned int jresult ;
69597   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69598   unsigned int arg2 ;
69599   bool result;
69600
69601   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69602   arg2 = (unsigned int)jarg2;
69603   {
69604     try {
69605       result = (bool)(arg1)->Within(arg2);
69606     } catch (std::out_of_range& e) {
69607       {
69608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69609       };
69610     } catch (std::exception& e) {
69611       {
69612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69613       };
69614     } catch (...) {
69615       {
69616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69617       };
69618     }
69619   }
69620   jresult = result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69626   void * jresult ;
69627   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69628   Dali::Toolkit::ItemRange *arg2 = 0 ;
69629   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69630
69631   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69632   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69633   if (!arg2) {
69634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69635     return 0;
69636   }
69637   {
69638     try {
69639       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69640     } catch (std::out_of_range& e) {
69641       {
69642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69643       };
69644     } catch (std::exception& e) {
69645       {
69646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69647       };
69648     } catch (...) {
69649       {
69650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69651       };
69652     }
69653   }
69654   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69655   return jresult;
69656 }
69657
69658
69659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69660   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69661   unsigned int arg2 ;
69662
69663   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69664   arg2 = (unsigned int)jarg2;
69665   if (arg1) (arg1)->begin = arg2;
69666 }
69667
69668
69669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69670   unsigned int jresult ;
69671   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69672   unsigned int result;
69673
69674   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69675   result = (unsigned int) ((arg1)->begin);
69676   jresult = result;
69677   return jresult;
69678 }
69679
69680
69681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69682   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69683   unsigned int arg2 ;
69684
69685   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69686   arg2 = (unsigned int)jarg2;
69687   if (arg1) (arg1)->end = arg2;
69688 }
69689
69690
69691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69692   unsigned int jresult ;
69693   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69694   unsigned int result;
69695
69696   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69697   result = (unsigned int) ((arg1)->end);
69698   jresult = result;
69699   return jresult;
69700 }
69701
69702
69703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69704   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69705
69706   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69707   {
69708     try {
69709       delete arg1;
69710     } catch (std::out_of_range& e) {
69711       {
69712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69713       };
69714     } catch (std::exception& e) {
69715       {
69716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69717       };
69718     } catch (...) {
69719       {
69720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69721       };
69722     }
69723   }
69724 }
69725
69726
69727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69728   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69729
69730   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69731   {
69732     try {
69733       delete arg1;
69734     } catch (std::out_of_range& e) {
69735       {
69736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69737       };
69738     } catch (std::exception& e) {
69739       {
69740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69741       };
69742     } catch (...) {
69743       {
69744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69745       };
69746     }
69747   }
69748 }
69749
69750
69751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69752   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69753   Dali::Toolkit::ControlOrientation::Type arg2 ;
69754
69755   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69756   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69757   {
69758     try {
69759       (arg1)->SetOrientation(arg2);
69760     } catch (std::out_of_range& e) {
69761       {
69762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69763       };
69764     } catch (std::exception& e) {
69765       {
69766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69767       };
69768     } catch (...) {
69769       {
69770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69771       };
69772     }
69773   }
69774 }
69775
69776
69777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69778   int jresult ;
69779   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69780   Dali::Toolkit::ControlOrientation::Type result;
69781
69782   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69783   {
69784     try {
69785       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69786     } catch (std::out_of_range& e) {
69787       {
69788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69789       };
69790     } catch (std::exception& e) {
69791       {
69792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69793       };
69794     } catch (...) {
69795       {
69796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69797       };
69798     }
69799   }
69800   jresult = (int)result;
69801   return jresult;
69802 }
69803
69804
69805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69806   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69807   Dali::Property::Map *arg2 = 0 ;
69808
69809   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69810   arg2 = (Dali::Property::Map *)jarg2;
69811   if (!arg2) {
69812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69813     return ;
69814   }
69815   {
69816     try {
69817       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69818     } catch (std::out_of_range& e) {
69819       {
69820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69821       };
69822     } catch (std::exception& e) {
69823       {
69824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69825       };
69826     } catch (...) {
69827       {
69828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69829       };
69830     }
69831   }
69832 }
69833
69834
69835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69836   void * jresult ;
69837   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69838   Dali::Property::Map result;
69839
69840   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69841   {
69842     try {
69843       result = (arg1)->GetLayoutProperties();
69844     } catch (std::out_of_range& e) {
69845       {
69846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69847       };
69848     } catch (std::exception& e) {
69849       {
69850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69851       };
69852     } catch (...) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69855       };
69856     }
69857   }
69858   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69859   return jresult;
69860 }
69861
69862
69863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69865   unsigned int arg2 ;
69866   Dali::Vector3 *arg3 = 0 ;
69867   Dali::Vector3 *arg4 = 0 ;
69868
69869   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69870   arg2 = (unsigned int)jarg2;
69871   arg3 = (Dali::Vector3 *)jarg3;
69872   if (!arg3) {
69873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69874     return ;
69875   }
69876   arg4 = (Dali::Vector3 *)jarg4;
69877   if (!arg4) {
69878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69879     return ;
69880   }
69881   {
69882     try {
69883       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69884     } catch (std::out_of_range& e) {
69885       {
69886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69887       };
69888     } catch (std::exception& e) {
69889       {
69890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69891       };
69892     } catch (...) {
69893       {
69894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69895       };
69896     }
69897   }
69898 }
69899
69900
69901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69903   Dali::Vector3 *arg2 = 0 ;
69904
69905   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69906   arg2 = (Dali::Vector3 *)jarg2;
69907   if (!arg2) {
69908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69909     return ;
69910   }
69911   {
69912     try {
69913       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69914     } catch (std::out_of_range& e) {
69915       {
69916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69917       };
69918     } catch (std::exception& e) {
69919       {
69920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69921       };
69922     } catch (...) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69925       };
69926     }
69927   }
69928 }
69929
69930
69931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69932   float jresult ;
69933   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69934   unsigned int arg2 ;
69935   Dali::Vector3 arg3 ;
69936   Dali::Vector3 *argp3 ;
69937   float result;
69938
69939   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69940   arg2 = (unsigned int)jarg2;
69941   argp3 = (Dali::Vector3 *)jarg3;
69942   if (!argp3) {
69943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69944     return 0;
69945   }
69946   arg3 = *argp3;
69947   {
69948     try {
69949       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69950     } catch (std::out_of_range& e) {
69951       {
69952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (std::exception& e) {
69955       {
69956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69957       };
69958     } catch (...) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69961       };
69962     }
69963   }
69964   jresult = result;
69965   return jresult;
69966 }
69967
69968
69969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69970   float jresult ;
69971   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69972   float arg2 ;
69973   float result;
69974
69975   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69976   arg2 = (float)jarg2;
69977   {
69978     try {
69979       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69980     } catch (std::out_of_range& e) {
69981       {
69982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (std::exception& e) {
69985       {
69986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69987       };
69988     } catch (...) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69991       };
69992     }
69993   }
69994   jresult = result;
69995   return jresult;
69996 }
69997
69998
69999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70000   float jresult ;
70001   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70002   unsigned int arg2 ;
70003   float result;
70004
70005   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70006   arg2 = (unsigned int)jarg2;
70007   {
70008     try {
70009       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70010     } catch (std::out_of_range& e) {
70011       {
70012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70013       };
70014     } catch (std::exception& e) {
70015       {
70016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70017       };
70018     } catch (...) {
70019       {
70020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70021       };
70022     }
70023   }
70024   jresult = result;
70025   return jresult;
70026 }
70027
70028
70029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70030   void * jresult ;
70031   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70032   float arg2 ;
70033   Dali::Vector3 arg3 ;
70034   Dali::Vector3 *argp3 ;
70035   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70036
70037   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70038   arg2 = (float)jarg2;
70039   argp3 = (Dali::Vector3 *)jarg3;
70040   if (!argp3) {
70041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70042     return 0;
70043   }
70044   arg3 = *argp3;
70045   {
70046     try {
70047       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (...) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70059       };
70060     }
70061   }
70062   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70063   return jresult;
70064 }
70065
70066
70067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70068   float jresult ;
70069   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70070   int arg2 ;
70071   float arg3 ;
70072   Dali::Vector3 *arg4 = 0 ;
70073   float result;
70074
70075   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70076   arg2 = (int)jarg2;
70077   arg3 = (float)jarg3;
70078   arg4 = (Dali::Vector3 *)jarg4;
70079   if (!arg4) {
70080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70081     return 0;
70082   }
70083   {
70084     try {
70085       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70086     } catch (std::out_of_range& e) {
70087       {
70088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70089       };
70090     } catch (std::exception& e) {
70091       {
70092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70093       };
70094     } catch (...) {
70095       {
70096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70097       };
70098     }
70099   }
70100   jresult = result;
70101   return jresult;
70102 }
70103
70104
70105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70106   unsigned int jresult ;
70107   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70108   Dali::Vector3 arg2 ;
70109   Dali::Vector3 *argp2 ;
70110   unsigned int result;
70111
70112   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70113   argp2 = (Dali::Vector3 *)jarg2;
70114   if (!argp2) {
70115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70116     return 0;
70117   }
70118   arg2 = *argp2;
70119   {
70120     try {
70121       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70122     } catch (std::out_of_range& e) {
70123       {
70124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70125       };
70126     } catch (std::exception& e) {
70127       {
70128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70129       };
70130     } catch (...) {
70131       {
70132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70133       };
70134     }
70135   }
70136   jresult = result;
70137   return jresult;
70138 }
70139
70140
70141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70142   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70143   unsigned int arg2 ;
70144   Dali::Vector3 *arg3 = 0 ;
70145   Dali::Vector3 *arg4 = 0 ;
70146
70147   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70148   arg2 = (unsigned int)jarg2;
70149   arg3 = (Dali::Vector3 *)jarg3;
70150   if (!arg3) {
70151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70152     return ;
70153   }
70154   arg4 = (Dali::Vector3 *)jarg4;
70155   if (!arg4) {
70156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70157     return ;
70158   }
70159   {
70160     try {
70161       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70162     } catch (std::out_of_range& e) {
70163       {
70164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70165       };
70166     } catch (std::exception& e) {
70167       {
70168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70169       };
70170     } catch (...) {
70171       {
70172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70173       };
70174     }
70175   }
70176 }
70177
70178
70179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70180   void * jresult ;
70181   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70182   Dali::Degree result;
70183
70184   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70185   {
70186     try {
70187       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70188     } catch (std::out_of_range& e) {
70189       {
70190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70191       };
70192     } catch (std::exception& e) {
70193       {
70194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70195       };
70196     } catch (...) {
70197       {
70198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70199       };
70200     }
70201   }
70202   jresult = new Dali::Degree((const Dali::Degree &)result);
70203   return jresult;
70204 }
70205
70206
70207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70208   float jresult ;
70209   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70210   float result;
70211
70212   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70213   {
70214     try {
70215       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70216     } catch (std::out_of_range& e) {
70217       {
70218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70219       };
70220     } catch (std::exception& e) {
70221       {
70222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70223       };
70224     } catch (...) {
70225       {
70226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70227       };
70228     }
70229   }
70230   jresult = result;
70231   return jresult;
70232 }
70233
70234
70235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70236   float jresult ;
70237   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70238   float result;
70239
70240   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70241   {
70242     try {
70243       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70244     } catch (std::out_of_range& e) {
70245       {
70246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70247       };
70248     } catch (std::exception& e) {
70249       {
70250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70251       };
70252     } catch (...) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70255       };
70256     }
70257   }
70258   jresult = result;
70259   return jresult;
70260 }
70261
70262
70263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70264   float jresult ;
70265   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70266   float result;
70267
70268   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70269   {
70270     try {
70271       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70272     } catch (std::out_of_range& e) {
70273       {
70274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70275       };
70276     } catch (std::exception& e) {
70277       {
70278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70279       };
70280     } catch (...) {
70281       {
70282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70283       };
70284     }
70285   }
70286   jresult = result;
70287   return jresult;
70288 }
70289
70290
70291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70292   int jresult ;
70293   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70294   int arg2 ;
70295   int arg3 ;
70296   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70297   bool arg5 ;
70298   int result;
70299
70300   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70301   arg2 = (int)jarg2;
70302   arg3 = (int)jarg3;
70303   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70304   arg5 = jarg5 ? true : false;
70305   {
70306     try {
70307       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70308     } catch (std::out_of_range& e) {
70309       {
70310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (std::exception& e) {
70313       {
70314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70315       };
70316     } catch (...) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70319       };
70320     }
70321   }
70322   jresult = result;
70323   return jresult;
70324 }
70325
70326
70327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70328   float jresult ;
70329   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70330   float result;
70331
70332   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70333   {
70334     try {
70335       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70336     } catch (std::out_of_range& e) {
70337       {
70338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70339       };
70340     } catch (std::exception& e) {
70341       {
70342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70343       };
70344     } catch (...) {
70345       {
70346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70347       };
70348     }
70349   }
70350   jresult = result;
70351   return jresult;
70352 }
70353
70354
70355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70356   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70357   Dali::Actor *arg2 = 0 ;
70358   int arg3 ;
70359   Dali::Vector3 *arg4 = 0 ;
70360   Dali::Actor *arg5 = 0 ;
70361
70362   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70363   arg2 = (Dali::Actor *)jarg2;
70364   if (!arg2) {
70365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70366     return ;
70367   }
70368   arg3 = (int)jarg3;
70369   arg4 = (Dali::Vector3 *)jarg4;
70370   if (!arg4) {
70371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70372     return ;
70373   }
70374   arg5 = (Dali::Actor *)jarg5;
70375   if (!arg5) {
70376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70377     return ;
70378   }
70379   {
70380     try {
70381       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70382     } catch (std::out_of_range& e) {
70383       {
70384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70385       };
70386     } catch (std::exception& e) {
70387       {
70388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70389       };
70390     } catch (...) {
70391       {
70392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70393       };
70394     }
70395   }
70396 }
70397
70398
70399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70400   void * jresult ;
70401   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70402   int arg2 ;
70403   float arg3 ;
70404   Dali::Vector3 *arg4 = 0 ;
70405   Dali::Vector3 result;
70406
70407   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70408   arg2 = (int)jarg2;
70409   arg3 = (float)jarg3;
70410   arg4 = (Dali::Vector3 *)jarg4;
70411   if (!arg4) {
70412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70413     return 0;
70414   }
70415   {
70416     try {
70417       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (...) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70429       };
70430     }
70431   }
70432   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70433   return jresult;
70434 }
70435
70436
70437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70438   void * jresult ;
70439   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70440   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70441
70442   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70443   {
70444     try {
70445       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70446     } catch (std::out_of_range& e) {
70447       {
70448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70449       };
70450     } catch (std::exception& e) {
70451       {
70452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70453       };
70454     } catch (...) {
70455       {
70456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70457       };
70458     }
70459   }
70460   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70461   return jresult;
70462 }
70463
70464
70465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70466   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70467
70468   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70469   {
70470     try {
70471       delete arg1;
70472     } catch (std::out_of_range& e) {
70473       {
70474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70475       };
70476     } catch (std::exception& e) {
70477       {
70478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70479       };
70480     } catch (...) {
70481       {
70482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70483       };
70484     }
70485   }
70486 }
70487
70488
70489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70490   unsigned int jresult ;
70491   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70492   unsigned int result;
70493
70494   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70495   {
70496     try {
70497       result = (unsigned int)(arg1)->GetNumberOfItems();
70498     } catch (std::out_of_range& e) {
70499       {
70500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70501       };
70502     } catch (std::exception& e) {
70503       {
70504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70505       };
70506     } catch (...) {
70507       {
70508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70509       };
70510     }
70511   }
70512   jresult = result;
70513   return jresult;
70514 }
70515
70516
70517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70518   void * jresult ;
70519   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70520   unsigned int arg2 ;
70521   Dali::Actor result;
70522
70523   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70524   arg2 = (unsigned int)jarg2;
70525   {
70526     try {
70527       result = (arg1)->NewItem(arg2);
70528     } catch (std::out_of_range& e) {
70529       {
70530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (std::exception& e) {
70533       {
70534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70535       };
70536     } catch (...) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70539       };
70540     }
70541   }
70542   jresult = new Dali::Actor((const Dali::Actor &)result);
70543   return jresult;
70544 }
70545
70546
70547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70548   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70549   unsigned int arg2 ;
70550   Dali::Actor arg3 ;
70551   Dali::Actor *argp3 ;
70552
70553   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70554   arg2 = (unsigned int)jarg2;
70555   argp3 = (Dali::Actor *)jarg3;
70556   if (!argp3) {
70557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70558     return ;
70559   }
70560   arg3 = *argp3;
70561   {
70562     try {
70563       (arg1)->ItemReleased(arg2,arg3);
70564     } catch (std::out_of_range& e) {
70565       {
70566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70567       };
70568     } catch (std::exception& e) {
70569       {
70570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70571       };
70572     } catch (...) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70575       };
70576     }
70577   }
70578 }
70579
70580
70581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70582   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70583   unsigned int arg2 ;
70584   Dali::Actor arg3 ;
70585   Dali::Actor *argp3 ;
70586
70587   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70588   arg2 = (unsigned int)jarg2;
70589   argp3 = (Dali::Actor *)jarg3;
70590   if (!argp3) {
70591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70592     return ;
70593   }
70594   arg3 = *argp3;
70595   {
70596     try {
70597       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70598     } catch (std::out_of_range& e) {
70599       {
70600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70601       };
70602     } catch (std::exception& e) {
70603       {
70604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70609       };
70610     }
70611   }
70612 }
70613
70614
70615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70616   void * jresult ;
70617   Dali::Toolkit::ItemFactory *result = 0 ;
70618
70619   {
70620     try {
70621       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70622     } catch (std::out_of_range& e) {
70623       {
70624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70625       };
70626     } catch (std::exception& e) {
70627       {
70628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70629       };
70630     } catch (...) {
70631       {
70632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70633       };
70634     }
70635   }
70636   jresult = (void *)result;
70637   return jresult;
70638 }
70639
70640
70641 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) {
70642   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70643   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70644   if (director) {
70645     director->swig_connect_director(callback0, callback1, callback2);
70646   }
70647 }
70648
70649
70650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70651   int jresult ;
70652   int result;
70653
70654   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70655   jresult = (int)result;
70656   return jresult;
70657 }
70658
70659
70660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70661   int jresult ;
70662   int result;
70663
70664   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70665   jresult = (int)result;
70666   return jresult;
70667 }
70668
70669
70670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70671   int jresult ;
70672   int result;
70673
70674   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70675   jresult = (int)result;
70676   return jresult;
70677 }
70678
70679
70680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70681   int jresult ;
70682   int result;
70683
70684   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70685   jresult = (int)result;
70686   return jresult;
70687 }
70688
70689
70690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70691   int jresult ;
70692   int result;
70693
70694   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70695   jresult = (int)result;
70696   return jresult;
70697 }
70698
70699
70700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70701   int jresult ;
70702   int result;
70703
70704   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70705   jresult = (int)result;
70706   return jresult;
70707 }
70708
70709
70710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70711   int jresult ;
70712   int result;
70713
70714   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70715   jresult = (int)result;
70716   return jresult;
70717 }
70718
70719
70720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70721   int jresult ;
70722   int result;
70723
70724   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70725   jresult = (int)result;
70726   return jresult;
70727 }
70728
70729
70730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70731   int jresult ;
70732   int result;
70733
70734   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70735   jresult = (int)result;
70736   return jresult;
70737 }
70738
70739
70740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70741   int jresult ;
70742   int result;
70743
70744   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70745   jresult = (int)result;
70746   return jresult;
70747 }
70748
70749
70750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70751   int jresult ;
70752   int result;
70753
70754   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70755   jresult = (int)result;
70756   return jresult;
70757 }
70758
70759
70760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70761   void * jresult ;
70762   Dali::Toolkit::ItemView::Property *result = 0 ;
70763
70764   {
70765     try {
70766       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70767     } catch (std::out_of_range& e) {
70768       {
70769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70770       };
70771     } catch (std::exception& e) {
70772       {
70773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70774       };
70775     } catch (...) {
70776       {
70777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70778       };
70779     }
70780   }
70781   jresult = (void *)result;
70782   return jresult;
70783 }
70784
70785
70786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70787   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70788
70789   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70790   {
70791     try {
70792       delete arg1;
70793     } catch (std::out_of_range& e) {
70794       {
70795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70796       };
70797     } catch (std::exception& e) {
70798       {
70799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70800       };
70801     } catch (...) {
70802       {
70803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70804       };
70805     }
70806   }
70807 }
70808
70809
70810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70811   void * jresult ;
70812   Dali::Toolkit::ItemView *result = 0 ;
70813
70814   {
70815     try {
70816       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70817     } catch (std::out_of_range& e) {
70818       {
70819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70820       };
70821     } catch (std::exception& e) {
70822       {
70823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70824       };
70825     } catch (...) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70828       };
70829     }
70830   }
70831   jresult = (void *)result;
70832   return jresult;
70833 }
70834
70835
70836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70837   void * jresult ;
70838   Dali::Toolkit::ItemView *arg1 = 0 ;
70839   Dali::Toolkit::ItemView *result = 0 ;
70840
70841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70842   if (!arg1) {
70843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70844     return 0;
70845   }
70846   {
70847     try {
70848       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70849     } catch (std::out_of_range& e) {
70850       {
70851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70852       };
70853     } catch (std::exception& e) {
70854       {
70855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70856       };
70857     } catch (...) {
70858       {
70859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70860       };
70861     }
70862   }
70863   jresult = (void *)result;
70864   return jresult;
70865 }
70866
70867
70868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70869   void * jresult ;
70870   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70871   Dali::Toolkit::ItemView *arg2 = 0 ;
70872   Dali::Toolkit::ItemView *result = 0 ;
70873
70874   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70875   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70876   if (!arg2) {
70877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70878     return 0;
70879   }
70880   {
70881     try {
70882       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70883     } catch (std::out_of_range& e) {
70884       {
70885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70886       };
70887     } catch (std::exception& e) {
70888       {
70889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70890       };
70891     } catch (...) {
70892       {
70893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70894       };
70895     }
70896   }
70897   jresult = (void *)result;
70898   return jresult;
70899 }
70900
70901
70902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70903   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70904
70905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70906   {
70907     try {
70908       delete arg1;
70909     } catch (std::out_of_range& e) {
70910       {
70911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (std::exception& e) {
70914       {
70915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (...) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70920       };
70921     }
70922   }
70923 }
70924
70925
70926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70927   void * jresult ;
70928   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70929   Dali::Toolkit::ItemView result;
70930
70931   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70932   if (!arg1) {
70933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70934     return 0;
70935   }
70936   {
70937     try {
70938       result = Dali::Toolkit::ItemView::New(*arg1);
70939     } catch (std::out_of_range& e) {
70940       {
70941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (std::exception& e) {
70944       {
70945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70954   return jresult;
70955 }
70956
70957
70958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70959   void * jresult ;
70960   Dali::BaseHandle arg1 ;
70961   Dali::BaseHandle *argp1 ;
70962   Dali::Toolkit::ItemView result;
70963
70964   argp1 = (Dali::BaseHandle *)jarg1;
70965   if (!argp1) {
70966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70967     return 0;
70968   }
70969   arg1 = *argp1;
70970   {
70971     try {
70972       result = Dali::Toolkit::ItemView::DownCast(arg1);
70973     } catch (std::out_of_range& e) {
70974       {
70975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70976       };
70977     } catch (std::exception& e) {
70978       {
70979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70980       };
70981     } catch (...) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70984       };
70985     }
70986   }
70987   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70988   return jresult;
70989 }
70990
70991
70992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70993   unsigned int jresult ;
70994   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70995   unsigned int result;
70996
70997   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70998   {
70999     try {
71000       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71001     } catch (std::out_of_range& e) {
71002       {
71003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71004       };
71005     } catch (std::exception& e) {
71006       {
71007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71008       };
71009     } catch (...) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71012       };
71013     }
71014   }
71015   jresult = result;
71016   return jresult;
71017 }
71018
71019
71020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71021   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71022   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71023
71024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71025   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71026   if (!arg2) {
71027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71028     return ;
71029   }
71030   {
71031     try {
71032       (arg1)->AddLayout(*arg2);
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71040       };
71041     } catch (...) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71044       };
71045     }
71046   }
71047 }
71048
71049
71050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71051   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71052   unsigned int arg2 ;
71053
71054   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71055   arg2 = (unsigned int)jarg2;
71056   {
71057     try {
71058       (arg1)->RemoveLayout(arg2);
71059     } catch (std::out_of_range& e) {
71060       {
71061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71062       };
71063     } catch (std::exception& e) {
71064       {
71065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71066       };
71067     } catch (...) {
71068       {
71069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71070       };
71071     }
71072   }
71073 }
71074
71075
71076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71077   void * jresult ;
71078   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71079   unsigned int arg2 ;
71080   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71081
71082   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71083   arg2 = (unsigned int)jarg2;
71084   {
71085     try {
71086       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71087     } catch (std::out_of_range& e) {
71088       {
71089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71090       };
71091     } catch (std::exception& e) {
71092       {
71093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71094       };
71095     } catch (...) {
71096       {
71097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71098       };
71099     }
71100   }
71101   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71102   return jresult;
71103 }
71104
71105
71106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71107   void * jresult ;
71108   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71109   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71110
71111   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71112   {
71113     try {
71114       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71115     } catch (std::out_of_range& e) {
71116       {
71117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71118       };
71119     } catch (std::exception& e) {
71120       {
71121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71122       };
71123     } catch (...) {
71124       {
71125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71126       };
71127     }
71128   }
71129   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71130   return jresult;
71131 }
71132
71133
71134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71135   float jresult ;
71136   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71137   Dali::Toolkit::ItemId arg2 ;
71138   float result;
71139
71140   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71141   arg2 = (Dali::Toolkit::ItemId)jarg2;
71142   {
71143     try {
71144       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71145     } catch (std::out_of_range& e) {
71146       {
71147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71148       };
71149     } catch (std::exception& e) {
71150       {
71151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71152       };
71153     } catch (...) {
71154       {
71155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71156       };
71157     }
71158   }
71159   jresult = result;
71160   return jresult;
71161 }
71162
71163
71164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71165   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71166   unsigned int arg2 ;
71167   Dali::Vector3 arg3 ;
71168   float arg4 ;
71169   Dali::Vector3 *argp3 ;
71170
71171   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71172   arg2 = (unsigned int)jarg2;
71173   argp3 = (Dali::Vector3 *)jarg3;
71174   if (!argp3) {
71175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71176     return ;
71177   }
71178   arg3 = *argp3;
71179   arg4 = (float)jarg4;
71180   {
71181     try {
71182       (arg1)->ActivateLayout(arg2,arg3,arg4);
71183     } catch (std::out_of_range& e) {
71184       {
71185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71186       };
71187     } catch (std::exception& e) {
71188       {
71189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71190       };
71191     } catch (...) {
71192       {
71193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71194       };
71195     }
71196   }
71197 }
71198
71199
71200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71202
71203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71204   {
71205     try {
71206       (arg1)->DeactivateCurrentLayout();
71207     } catch (std::out_of_range& e) {
71208       {
71209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71210       };
71211     } catch (std::exception& e) {
71212       {
71213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71214       };
71215     } catch (...) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71218       };
71219     }
71220   }
71221 }
71222
71223
71224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71225   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71226   float arg2 ;
71227
71228   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71229   arg2 = (float)jarg2;
71230   {
71231     try {
71232       (arg1)->SetMinimumSwipeSpeed(arg2);
71233     } catch (std::out_of_range& e) {
71234       {
71235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71236       };
71237     } catch (std::exception& e) {
71238       {
71239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71240       };
71241     } catch (...) {
71242       {
71243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71244       };
71245     }
71246   }
71247 }
71248
71249
71250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71251   float jresult ;
71252   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71253   float result;
71254
71255   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71256   {
71257     try {
71258       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71259     } catch (std::out_of_range& e) {
71260       {
71261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71262       };
71263     } catch (std::exception& e) {
71264       {
71265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71266       };
71267     } catch (...) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71270       };
71271     }
71272   }
71273   jresult = result;
71274   return jresult;
71275 }
71276
71277
71278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71279   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71280   float arg2 ;
71281
71282   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71283   arg2 = (float)jarg2;
71284   {
71285     try {
71286       (arg1)->SetMinimumSwipeDistance(arg2);
71287     } catch (std::out_of_range& e) {
71288       {
71289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71290       };
71291     } catch (std::exception& e) {
71292       {
71293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71294       };
71295     } catch (...) {
71296       {
71297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71298       };
71299     }
71300   }
71301 }
71302
71303
71304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71305   float jresult ;
71306   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71307   float result;
71308
71309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71310   {
71311     try {
71312       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71313     } catch (std::out_of_range& e) {
71314       {
71315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71316       };
71317     } catch (std::exception& e) {
71318       {
71319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71320       };
71321     } catch (...) {
71322       {
71323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71324       };
71325     }
71326   }
71327   jresult = result;
71328   return jresult;
71329 }
71330
71331
71332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71334   float arg2 ;
71335
71336   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71337   arg2 = (float)jarg2;
71338   {
71339     try {
71340       (arg1)->SetWheelScrollDistanceStep(arg2);
71341     } catch (std::out_of_range& e) {
71342       {
71343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71344       };
71345     } catch (std::exception& e) {
71346       {
71347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71348       };
71349     } catch (...) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71352       };
71353     }
71354   }
71355 }
71356
71357
71358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71359   float jresult ;
71360   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71361   float result;
71362
71363   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71364   {
71365     try {
71366       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71367     } catch (std::out_of_range& e) {
71368       {
71369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71370       };
71371     } catch (std::exception& e) {
71372       {
71373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71374       };
71375     } catch (...) {
71376       {
71377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71378       };
71379     }
71380   }
71381   jresult = result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71387   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71388   bool arg2 ;
71389
71390   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71391   arg2 = jarg2 ? true : false;
71392   {
71393     try {
71394       (arg1)->SetAnchoring(arg2);
71395     } catch (std::out_of_range& e) {
71396       {
71397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71398       };
71399     } catch (std::exception& e) {
71400       {
71401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71406       };
71407     }
71408   }
71409 }
71410
71411
71412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71413   unsigned int jresult ;
71414   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71415   bool result;
71416
71417   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71418   {
71419     try {
71420       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71421     } catch (std::out_of_range& e) {
71422       {
71423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71424       };
71425     } catch (std::exception& e) {
71426       {
71427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71428       };
71429     } catch (...) {
71430       {
71431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71432       };
71433     }
71434   }
71435   jresult = result;
71436   return jresult;
71437 }
71438
71439
71440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71442   float arg2 ;
71443
71444   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71445   arg2 = (float)jarg2;
71446   {
71447     try {
71448       (arg1)->SetAnchoringDuration(arg2);
71449     } catch (std::out_of_range& e) {
71450       {
71451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (std::exception& e) {
71454       {
71455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71460       };
71461     }
71462   }
71463 }
71464
71465
71466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71467   float jresult ;
71468   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71469   float result;
71470
71471   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71472   {
71473     try {
71474       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71475     } catch (std::out_of_range& e) {
71476       {
71477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71478       };
71479     } catch (std::exception& e) {
71480       {
71481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71482       };
71483     } catch (...) {
71484       {
71485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71486       };
71487     }
71488   }
71489   jresult = result;
71490   return jresult;
71491 }
71492
71493
71494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71495   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71496   Dali::Toolkit::ItemId arg2 ;
71497   float arg3 ;
71498
71499   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71500   arg2 = (Dali::Toolkit::ItemId)jarg2;
71501   arg3 = (float)jarg3;
71502   {
71503     try {
71504       (arg1)->ScrollToItem(arg2,arg3);
71505     } catch (std::out_of_range& e) {
71506       {
71507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71508       };
71509     } catch (std::exception& e) {
71510       {
71511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71512       };
71513     } catch (...) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71516       };
71517     }
71518   }
71519 }
71520
71521
71522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71523   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71524   float arg2 ;
71525
71526   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71527   arg2 = (float)jarg2;
71528   {
71529     try {
71530       (arg1)->SetRefreshInterval(arg2);
71531     } catch (std::out_of_range& e) {
71532       {
71533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71534       };
71535     } catch (std::exception& e) {
71536       {
71537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71538       };
71539     } catch (...) {
71540       {
71541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71542       };
71543     }
71544   }
71545 }
71546
71547
71548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71549   float jresult ;
71550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71551   float result;
71552
71553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71554   {
71555     try {
71556       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71557     } catch (std::out_of_range& e) {
71558       {
71559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71560       };
71561     } catch (std::exception& e) {
71562       {
71563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71564       };
71565     } catch (...) {
71566       {
71567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71568       };
71569     }
71570   }
71571   jresult = result;
71572   return jresult;
71573 }
71574
71575
71576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71577   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71578
71579   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71580   {
71581     try {
71582       (arg1)->Refresh();
71583     } catch (std::out_of_range& e) {
71584       {
71585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71586       };
71587     } catch (std::exception& e) {
71588       {
71589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71590       };
71591     } catch (...) {
71592       {
71593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71594       };
71595     }
71596   }
71597 }
71598
71599
71600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71601   void * jresult ;
71602   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71603   Dali::Toolkit::ItemId arg2 ;
71604   Dali::Actor result;
71605
71606   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71607   arg2 = (Dali::Toolkit::ItemId)jarg2;
71608   {
71609     try {
71610       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71611     } catch (std::out_of_range& e) {
71612       {
71613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71614       };
71615     } catch (std::exception& e) {
71616       {
71617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71618       };
71619     } catch (...) {
71620       {
71621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71622       };
71623     }
71624   }
71625   jresult = new Dali::Actor((const Dali::Actor &)result);
71626   return jresult;
71627 }
71628
71629
71630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71631   unsigned int jresult ;
71632   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71633   Dali::Actor arg2 ;
71634   Dali::Actor *argp2 ;
71635   Dali::Toolkit::ItemId result;
71636
71637   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71638   argp2 = (Dali::Actor *)jarg2;
71639   if (!argp2) {
71640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71641     return 0;
71642   }
71643   arg2 = *argp2;
71644   {
71645     try {
71646       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71647     } catch (std::out_of_range& e) {
71648       {
71649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71650       };
71651     } catch (std::exception& e) {
71652       {
71653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71654       };
71655     } catch (...) {
71656       {
71657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71658       };
71659     }
71660   }
71661   jresult = result;
71662   return jresult;
71663 }
71664
71665
71666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71667   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71668   Dali::Toolkit::Item arg2 ;
71669   float arg3 ;
71670   Dali::Toolkit::Item *argp2 ;
71671
71672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71673   argp2 = (Dali::Toolkit::Item *)jarg2;
71674   if (!argp2) {
71675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71676     return ;
71677   }
71678   arg2 = *argp2;
71679   arg3 = (float)jarg3;
71680   {
71681     try {
71682       (arg1)->InsertItem(arg2,arg3);
71683     } catch (std::out_of_range& e) {
71684       {
71685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71686       };
71687     } catch (std::exception& e) {
71688       {
71689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71690       };
71691     } catch (...) {
71692       {
71693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71694       };
71695     }
71696   }
71697 }
71698
71699
71700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71701   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71702   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71703   float arg3 ;
71704
71705   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71706   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71707   if (!arg2) {
71708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71709     return ;
71710   }
71711   arg3 = (float)jarg3;
71712   {
71713     try {
71714       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71715     } catch (std::out_of_range& e) {
71716       {
71717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71718       };
71719     } catch (std::exception& e) {
71720       {
71721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71722       };
71723     } catch (...) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71726       };
71727     }
71728   }
71729 }
71730
71731
71732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71734   Dali::Toolkit::ItemId arg2 ;
71735   float arg3 ;
71736
71737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71738   arg2 = (Dali::Toolkit::ItemId)jarg2;
71739   arg3 = (float)jarg3;
71740   {
71741     try {
71742       (arg1)->RemoveItem(arg2,arg3);
71743     } catch (std::out_of_range& e) {
71744       {
71745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71746       };
71747     } catch (std::exception& e) {
71748       {
71749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71750       };
71751     } catch (...) {
71752       {
71753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71754       };
71755     }
71756   }
71757 }
71758
71759
71760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71761   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71762   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71763   float arg3 ;
71764
71765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71766   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71767   if (!arg2) {
71768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71769     return ;
71770   }
71771   arg3 = (float)jarg3;
71772   {
71773     try {
71774       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71775     } catch (std::out_of_range& e) {
71776       {
71777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71778       };
71779     } catch (std::exception& e) {
71780       {
71781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71782       };
71783     } catch (...) {
71784       {
71785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71786       };
71787     }
71788   }
71789 }
71790
71791
71792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71793   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71794   Dali::Toolkit::Item arg2 ;
71795   float arg3 ;
71796   Dali::Toolkit::Item *argp2 ;
71797
71798   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71799   argp2 = (Dali::Toolkit::Item *)jarg2;
71800   if (!argp2) {
71801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71802     return ;
71803   }
71804   arg2 = *argp2;
71805   arg3 = (float)jarg3;
71806   {
71807     try {
71808       (arg1)->ReplaceItem(arg2,arg3);
71809     } catch (std::out_of_range& e) {
71810       {
71811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71812       };
71813     } catch (std::exception& e) {
71814       {
71815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71816       };
71817     } catch (...) {
71818       {
71819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71820       };
71821     }
71822   }
71823 }
71824
71825
71826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71828   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71829   float arg3 ;
71830
71831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71832   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71833   if (!arg2) {
71834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71835     return ;
71836   }
71837   arg3 = (float)jarg3;
71838   {
71839     try {
71840       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71841     } catch (std::out_of_range& e) {
71842       {
71843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71844       };
71845     } catch (std::exception& e) {
71846       {
71847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71848       };
71849     } catch (...) {
71850       {
71851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71852       };
71853     }
71854   }
71855 }
71856
71857
71858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71859   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71860   Dali::Vector3 *arg2 = 0 ;
71861
71862   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71863   arg2 = (Dali::Vector3 *)jarg2;
71864   if (!arg2) {
71865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71866     return ;
71867   }
71868   {
71869     try {
71870       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71878       };
71879     } catch (...) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71882       };
71883     }
71884   }
71885 }
71886
71887
71888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71889   void * jresult ;
71890   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71891   Dali::Vector3 result;
71892
71893   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71894   {
71895     try {
71896       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71897     } catch (std::out_of_range& e) {
71898       {
71899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71900       };
71901     } catch (std::exception& e) {
71902       {
71903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71904       };
71905     } catch (...) {
71906       {
71907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71908       };
71909     }
71910   }
71911   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71912   return jresult;
71913 }
71914
71915
71916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71918   Dali::Vector3 *arg2 = 0 ;
71919
71920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71921   arg2 = (Dali::Vector3 *)jarg2;
71922   if (!arg2) {
71923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71924     return ;
71925   }
71926   {
71927     try {
71928       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71929     } catch (std::out_of_range& e) {
71930       {
71931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71932       };
71933     } catch (std::exception& e) {
71934       {
71935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (...) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71940       };
71941     }
71942   }
71943 }
71944
71945
71946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71947   void * jresult ;
71948   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71949   Dali::Vector3 result;
71950
71951   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71952   {
71953     try {
71954       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71955     } catch (std::out_of_range& e) {
71956       {
71957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71958       };
71959     } catch (std::exception& e) {
71960       {
71961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (...) {
71964       {
71965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71966       };
71967     }
71968   }
71969   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71970   return jresult;
71971 }
71972
71973
71974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71975   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71976   Dali::Toolkit::ItemRange *arg2 = 0 ;
71977
71978   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71979   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71980   if (!arg2) {
71981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71982     return ;
71983   }
71984   {
71985     try {
71986       (arg1)->GetItemsRange(*arg2);
71987     } catch (std::out_of_range& e) {
71988       {
71989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71990       };
71991     } catch (std::exception& e) {
71992       {
71993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71994       };
71995     } catch (...) {
71996       {
71997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71998       };
71999     }
72000   }
72001 }
72002
72003
72004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72005   void * jresult ;
72006   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72007   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72008
72009   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72010   {
72011     try {
72012       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72013     } catch (std::out_of_range& e) {
72014       {
72015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72016       };
72017     } catch (std::exception& e) {
72018       {
72019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72020       };
72021     } catch (...) {
72022       {
72023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72024       };
72025     }
72026   }
72027   jresult = (void *)result;
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72033   Dali::Vector3 *arg1 = 0 ;
72034   PropertyInputContainer *arg2 = 0 ;
72035
72036   arg1 = (Dali::Vector3 *)jarg1;
72037   if (!arg1) {
72038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72039     return ;
72040   }
72041   arg2 = (PropertyInputContainer *)jarg2;
72042   if (!arg2) {
72043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72044     return ;
72045   }
72046   {
72047     try {
72048       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72049     } catch (std::out_of_range& e) {
72050       {
72051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72052       };
72053     } catch (std::exception& e) {
72054       {
72055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72056       };
72057     } catch (...) {
72058       {
72059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72060       };
72061     }
72062   }
72063 }
72064
72065
72066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72067   Dali::Vector3 *arg1 = 0 ;
72068   PropertyInputContainer *arg2 = 0 ;
72069
72070   arg1 = (Dali::Vector3 *)jarg1;
72071   if (!arg1) {
72072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72073     return ;
72074   }
72075   arg2 = (PropertyInputContainer *)jarg2;
72076   if (!arg2) {
72077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72078     return ;
72079   }
72080   {
72081     try {
72082       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72083     } catch (std::out_of_range& e) {
72084       {
72085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72086       };
72087     } catch (std::exception& e) {
72088       {
72089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72090       };
72091     } catch (...) {
72092       {
72093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72094       };
72095     }
72096   }
72097 }
72098
72099
72100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72101   void * jresult ;
72102   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72103
72104   {
72105     try {
72106       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72107     } catch (std::out_of_range& e) {
72108       {
72109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72110       };
72111     } catch (std::exception& e) {
72112       {
72113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72114       };
72115     } catch (...) {
72116       {
72117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72118       };
72119     }
72120   }
72121   jresult = (void *)result;
72122   return jresult;
72123 }
72124
72125
72126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72127   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72128
72129   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72130   {
72131     try {
72132       delete arg1;
72133     } catch (std::out_of_range& e) {
72134       {
72135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72136       };
72137     } catch (std::exception& e) {
72138       {
72139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72140       };
72141     } catch (...) {
72142       {
72143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72144       };
72145     }
72146   }
72147 }
72148
72149
72150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72151   void * jresult ;
72152   Dali::Path arg1 ;
72153   Dali::Vector3 *arg2 = 0 ;
72154   Dali::Property::Index arg3 ;
72155   Dali::Vector3 *arg4 = 0 ;
72156   unsigned int arg5 ;
72157   Dali::Path *argp1 ;
72158   Dali::Toolkit::ScrollViewPagePathEffect result;
72159
72160   argp1 = (Dali::Path *)jarg1;
72161   if (!argp1) {
72162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72163     return 0;
72164   }
72165   arg1 = *argp1;
72166   arg2 = (Dali::Vector3 *)jarg2;
72167   if (!arg2) {
72168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72169     return 0;
72170   }
72171   arg3 = (Dali::Property::Index)jarg3;
72172   arg4 = (Dali::Vector3 *)jarg4;
72173   if (!arg4) {
72174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72175     return 0;
72176   }
72177   arg5 = (unsigned int)jarg5;
72178   {
72179     try {
72180       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72181     } catch (std::out_of_range& e) {
72182       {
72183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72184       };
72185     } catch (std::exception& e) {
72186       {
72187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72188       };
72189     } catch (...) {
72190       {
72191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72192       };
72193     }
72194   }
72195   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72196   return jresult;
72197 }
72198
72199
72200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72201   void * jresult ;
72202   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72203
72204   {
72205     try {
72206       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72207     } catch (std::out_of_range& e) {
72208       {
72209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72210       };
72211     } catch (std::exception& e) {
72212       {
72213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72214       };
72215     } catch (...) {
72216       {
72217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72218       };
72219     }
72220   }
72221   jresult = (void *)result;
72222   return jresult;
72223 }
72224
72225
72226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72227   void * jresult ;
72228   Dali::BaseHandle arg1 ;
72229   Dali::BaseHandle *argp1 ;
72230   Dali::Toolkit::ScrollViewPagePathEffect result;
72231
72232   argp1 = (Dali::BaseHandle *)jarg1;
72233   if (!argp1) {
72234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72235     return 0;
72236   }
72237   arg1 = *argp1;
72238   {
72239     try {
72240       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72241     } catch (std::out_of_range& e) {
72242       {
72243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72244       };
72245     } catch (std::exception& e) {
72246       {
72247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72248       };
72249     } catch (...) {
72250       {
72251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72252       };
72253     }
72254   }
72255   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72256   return jresult;
72257 }
72258
72259
72260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72261   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72262   Dali::Actor arg2 ;
72263   unsigned int arg3 ;
72264   Dali::Actor *argp2 ;
72265
72266   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72267   argp2 = (Dali::Actor *)jarg2;
72268   if (!argp2) {
72269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72270     return ;
72271   }
72272   arg2 = *argp2;
72273   arg3 = (unsigned int)jarg3;
72274   {
72275     try {
72276       (arg1)->ApplyToPage(arg2,arg3);
72277     } catch (std::out_of_range& e) {
72278       {
72279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72280       };
72281     } catch (std::exception& e) {
72282       {
72283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72284       };
72285     } catch (...) {
72286       {
72287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72288       };
72289     }
72290   }
72291 }
72292
72293
72294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72295   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72296
72297   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72298   {
72299     try {
72300       delete arg1;
72301     } catch (std::out_of_range& e) {
72302       {
72303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72304       };
72305     } catch (std::exception& e) {
72306       {
72307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72308       };
72309     } catch (...) {
72310       {
72311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72312       };
72313     }
72314   }
72315 }
72316
72317
72318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72319   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72320   Dali::Toolkit::ClampState arg2 ;
72321
72322   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72323   arg2 = (Dali::Toolkit::ClampState)jarg2;
72324   if (arg1) (arg1)->x = arg2;
72325 }
72326
72327
72328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72329   int jresult ;
72330   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72331   Dali::Toolkit::ClampState result;
72332
72333   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72334   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72335   jresult = (int)result;
72336   return jresult;
72337 }
72338
72339
72340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72341   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72342   Dali::Toolkit::ClampState arg2 ;
72343
72344   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72345   arg2 = (Dali::Toolkit::ClampState)jarg2;
72346   if (arg1) (arg1)->y = arg2;
72347 }
72348
72349
72350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72351   int jresult ;
72352   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72353   Dali::Toolkit::ClampState result;
72354
72355   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72356   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72357   jresult = (int)result;
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72363   void * jresult ;
72364   Dali::Toolkit::ClampState2D *result = 0 ;
72365
72366   {
72367     try {
72368       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72369     } catch (std::out_of_range& e) {
72370       {
72371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72372       };
72373     } catch (std::exception& e) {
72374       {
72375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72376       };
72377     } catch (...) {
72378       {
72379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72380       };
72381     }
72382   }
72383   jresult = (void *)result;
72384   return jresult;
72385 }
72386
72387
72388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72389   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72390
72391   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72392   {
72393     try {
72394       delete arg1;
72395     } catch (std::out_of_range& e) {
72396       {
72397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72398       };
72399     } catch (std::exception& e) {
72400       {
72401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72402       };
72403     } catch (...) {
72404       {
72405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72406       };
72407     }
72408   }
72409 }
72410
72411
72412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72413   void * jresult ;
72414   float arg1 ;
72415   float arg2 ;
72416   bool arg3 ;
72417   Dali::Toolkit::RulerDomain *result = 0 ;
72418
72419   arg1 = (float)jarg1;
72420   arg2 = (float)jarg2;
72421   arg3 = jarg3 ? true : false;
72422   {
72423     try {
72424       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72425     } catch (std::out_of_range& e) {
72426       {
72427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72428       };
72429     } catch (std::exception& e) {
72430       {
72431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (...) {
72434       {
72435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72436       };
72437     }
72438   }
72439   jresult = (void *)result;
72440   return jresult;
72441 }
72442
72443
72444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72445   void * jresult ;
72446   float arg1 ;
72447   float arg2 ;
72448   Dali::Toolkit::RulerDomain *result = 0 ;
72449
72450   arg1 = (float)jarg1;
72451   arg2 = (float)jarg2;
72452   {
72453     try {
72454       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72455     } catch (std::out_of_range& e) {
72456       {
72457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72458       };
72459     } catch (std::exception& e) {
72460       {
72461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72466       };
72467     }
72468   }
72469   jresult = (void *)result;
72470   return jresult;
72471 }
72472
72473
72474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72475   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72476   float arg2 ;
72477
72478   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72479   arg2 = (float)jarg2;
72480   if (arg1) (arg1)->min = arg2;
72481 }
72482
72483
72484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72485   float jresult ;
72486   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72487   float result;
72488
72489   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72490   result = (float) ((arg1)->min);
72491   jresult = result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72497   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72498   float arg2 ;
72499
72500   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72501   arg2 = (float)jarg2;
72502   if (arg1) (arg1)->max = arg2;
72503 }
72504
72505
72506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72507   float jresult ;
72508   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72509   float result;
72510
72511   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72512   result = (float) ((arg1)->max);
72513   jresult = result;
72514   return jresult;
72515 }
72516
72517
72518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72519   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72520   bool arg2 ;
72521
72522   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72523   arg2 = jarg2 ? true : false;
72524   if (arg1) (arg1)->enabled = arg2;
72525 }
72526
72527
72528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72529   unsigned int jresult ;
72530   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72531   bool result;
72532
72533   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72534   result = (bool) ((arg1)->enabled);
72535   jresult = result;
72536   return jresult;
72537 }
72538
72539
72540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72541   float jresult ;
72542   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72543   float arg2 ;
72544   float arg3 ;
72545   float arg4 ;
72546   float result;
72547
72548   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72549   arg2 = (float)jarg2;
72550   arg3 = (float)jarg3;
72551   arg4 = (float)jarg4;
72552   {
72553     try {
72554       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72555     } catch (std::out_of_range& e) {
72556       {
72557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (std::exception& e) {
72560       {
72561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72562       };
72563     } catch (...) {
72564       {
72565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72566       };
72567     }
72568   }
72569   jresult = result;
72570   return jresult;
72571 }
72572
72573
72574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72575   float jresult ;
72576   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72577   float arg2 ;
72578   float arg3 ;
72579   float result;
72580
72581   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72582   arg2 = (float)jarg2;
72583   arg3 = (float)jarg3;
72584   {
72585     try {
72586       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72587     } catch (std::out_of_range& e) {
72588       {
72589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72590       };
72591     } catch (std::exception& e) {
72592       {
72593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (...) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72598       };
72599     }
72600   }
72601   jresult = result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72607   float jresult ;
72608   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72609   float arg2 ;
72610   float result;
72611
72612   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72613   arg2 = (float)jarg2;
72614   {
72615     try {
72616       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72617     } catch (std::out_of_range& e) {
72618       {
72619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72620       };
72621     } catch (std::exception& e) {
72622       {
72623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72624       };
72625     } catch (...) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72628       };
72629     }
72630   }
72631   jresult = result;
72632   return jresult;
72633 }
72634
72635
72636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72637   float jresult ;
72638   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72639   float arg2 ;
72640   float arg3 ;
72641   float arg4 ;
72642   Dali::Toolkit::ClampState *arg5 = 0 ;
72643   float result;
72644
72645   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72646   arg2 = (float)jarg2;
72647   arg3 = (float)jarg3;
72648   arg4 = (float)jarg4;
72649   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72650   if (!arg5) {
72651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72652     return 0;
72653   }
72654   {
72655     try {
72656       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72657     } catch (std::out_of_range& e) {
72658       {
72659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (std::exception& e) {
72662       {
72663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72664       };
72665     } catch (...) {
72666       {
72667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72668       };
72669     }
72670   }
72671   jresult = result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72677   float jresult ;
72678   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72679   float result;
72680
72681   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72682   {
72683     try {
72684       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72685     } catch (std::out_of_range& e) {
72686       {
72687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (std::exception& e) {
72690       {
72691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72692       };
72693     } catch (...) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72696       };
72697     }
72698   }
72699   jresult = result;
72700   return jresult;
72701 }
72702
72703
72704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72705   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72706
72707   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72708   {
72709     try {
72710       delete arg1;
72711     } catch (std::out_of_range& e) {
72712       {
72713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72714       };
72715     } catch (std::exception& e) {
72716       {
72717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72718       };
72719     } catch (...) {
72720       {
72721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72722       };
72723     }
72724   }
72725 }
72726
72727
72728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72729   float jresult ;
72730   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72731   float arg2 ;
72732   float arg3 ;
72733   float result;
72734
72735   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72736   arg2 = (float)jarg2;
72737   arg3 = (float)jarg3;
72738   {
72739     try {
72740       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72741     } catch (std::out_of_range& e) {
72742       {
72743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72744       };
72745     } catch (std::exception& e) {
72746       {
72747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72748       };
72749     } catch (...) {
72750       {
72751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72752       };
72753     }
72754   }
72755   jresult = result;
72756   return jresult;
72757 }
72758
72759
72760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72761   float jresult ;
72762   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72763   float arg2 ;
72764   float result;
72765
72766   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72767   arg2 = (float)jarg2;
72768   {
72769     try {
72770       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72771     } catch (std::out_of_range& e) {
72772       {
72773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72774       };
72775     } catch (std::exception& e) {
72776       {
72777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72778       };
72779     } catch (...) {
72780       {
72781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72782       };
72783     }
72784   }
72785   jresult = result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72791   float jresult ;
72792   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72793   unsigned int arg2 ;
72794   unsigned int *arg3 = 0 ;
72795   bool arg4 ;
72796   float result;
72797
72798   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72799   arg2 = (unsigned int)jarg2;
72800   arg3 = (unsigned int *)jarg3;
72801   arg4 = jarg4 ? true : false;
72802   {
72803     try {
72804       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72805     } catch (std::out_of_range& e) {
72806       {
72807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72808       };
72809     } catch (std::exception& e) {
72810       {
72811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72812       };
72813     } catch (...) {
72814       {
72815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72816       };
72817     }
72818   }
72819   jresult = result;
72820   return jresult;
72821 }
72822
72823
72824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72825   unsigned int jresult ;
72826   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72827   float arg2 ;
72828   bool arg3 ;
72829   unsigned int result;
72830
72831   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72832   arg2 = (float)jarg2;
72833   arg3 = jarg3 ? true : false;
72834   {
72835     try {
72836       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72837     } catch (std::out_of_range& e) {
72838       {
72839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72840       };
72841     } catch (std::exception& e) {
72842       {
72843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72844       };
72845     } catch (...) {
72846       {
72847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72848       };
72849     }
72850   }
72851   jresult = result;
72852   return jresult;
72853 }
72854
72855
72856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72857   unsigned int jresult ;
72858   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72859   unsigned int result;
72860
72861   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72862   {
72863     try {
72864       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72865     } catch (std::out_of_range& e) {
72866       {
72867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72868       };
72869     } catch (std::exception& e) {
72870       {
72871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72872       };
72873     } catch (...) {
72874       {
72875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72876       };
72877     }
72878   }
72879   jresult = result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72885   int jresult ;
72886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72887   Dali::Toolkit::Ruler::RulerType result;
72888
72889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72890   {
72891     try {
72892       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72893     } catch (std::out_of_range& e) {
72894       {
72895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (std::exception& e) {
72898       {
72899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72900       };
72901     } catch (...) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72904       };
72905     }
72906   }
72907   jresult = (int)result;
72908   return jresult;
72909 }
72910
72911
72912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72913   unsigned int jresult ;
72914   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72915   bool result;
72916
72917   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72918   {
72919     try {
72920       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72921     } catch (std::out_of_range& e) {
72922       {
72923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72924       };
72925     } catch (std::exception& e) {
72926       {
72927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72928       };
72929     } catch (...) {
72930       {
72931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72932       };
72933     }
72934   }
72935   jresult = result;
72936   return jresult;
72937 }
72938
72939
72940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72941   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72942
72943   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72944   {
72945     try {
72946       (arg1)->Enable();
72947     } catch (std::out_of_range& e) {
72948       {
72949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72950       };
72951     } catch (std::exception& e) {
72952       {
72953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72954       };
72955     } catch (...) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72958       };
72959     }
72960   }
72961 }
72962
72963
72964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72965   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72966
72967   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72968   {
72969     try {
72970       (arg1)->Disable();
72971     } catch (std::out_of_range& e) {
72972       {
72973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72974       };
72975     } catch (std::exception& e) {
72976       {
72977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72982       };
72983     }
72984   }
72985 }
72986
72987
72988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72989   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72990   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72991   Dali::Toolkit::RulerDomain *argp2 ;
72992
72993   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72994   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72995   if (!argp2) {
72996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72997     return ;
72998   }
72999   arg2 = *argp2;
73000   {
73001     try {
73002       (arg1)->SetDomain(arg2);
73003     } catch (std::out_of_range& e) {
73004       {
73005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73006       };
73007     } catch (std::exception& e) {
73008       {
73009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73010       };
73011     } catch (...) {
73012       {
73013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73014       };
73015     }
73016   }
73017 }
73018
73019
73020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73021   void * jresult ;
73022   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73023   Dali::Toolkit::RulerDomain *result = 0 ;
73024
73025   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73026   {
73027     try {
73028       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73029     } catch (std::out_of_range& e) {
73030       {
73031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73032       };
73033     } catch (std::exception& e) {
73034       {
73035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (...) {
73038       {
73039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73040       };
73041     }
73042   }
73043   jresult = (void *)result;
73044   return jresult;
73045 }
73046
73047
73048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73049   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73050
73051   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73052   {
73053     try {
73054       (arg1)->DisableDomain();
73055     } catch (std::out_of_range& e) {
73056       {
73057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73058       };
73059     } catch (std::exception& e) {
73060       {
73061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73062       };
73063     } catch (...) {
73064       {
73065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73066       };
73067     }
73068   }
73069 }
73070
73071
73072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73073   float jresult ;
73074   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73075   float arg2 ;
73076   float arg3 ;
73077   float arg4 ;
73078   float result;
73079
73080   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73081   arg2 = (float)jarg2;
73082   arg3 = (float)jarg3;
73083   arg4 = (float)jarg4;
73084   {
73085     try {
73086       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73087     } catch (std::out_of_range& e) {
73088       {
73089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (std::exception& e) {
73092       {
73093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73094       };
73095     } catch (...) {
73096       {
73097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73098       };
73099     }
73100   }
73101   jresult = result;
73102   return jresult;
73103 }
73104
73105
73106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73107   float jresult ;
73108   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73109   float arg2 ;
73110   float arg3 ;
73111   float result;
73112
73113   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73114   arg2 = (float)jarg2;
73115   arg3 = (float)jarg3;
73116   {
73117     try {
73118       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73119     } catch (std::out_of_range& e) {
73120       {
73121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73122       };
73123     } catch (std::exception& e) {
73124       {
73125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73126       };
73127     } catch (...) {
73128       {
73129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73130       };
73131     }
73132   }
73133   jresult = result;
73134   return jresult;
73135 }
73136
73137
73138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73139   float jresult ;
73140   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73141   float arg2 ;
73142   float result;
73143
73144   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73145   arg2 = (float)jarg2;
73146   {
73147     try {
73148       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73149     } catch (std::out_of_range& e) {
73150       {
73151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73152       };
73153     } catch (std::exception& e) {
73154       {
73155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73156       };
73157     } catch (...) {
73158       {
73159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73160       };
73161     }
73162   }
73163   jresult = result;
73164   return jresult;
73165 }
73166
73167
73168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73169   float jresult ;
73170   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73171   float arg2 ;
73172   float arg3 ;
73173   float arg4 ;
73174   Dali::Toolkit::ClampState *arg5 = 0 ;
73175   float result;
73176
73177   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73178   arg2 = (float)jarg2;
73179   arg3 = (float)jarg3;
73180   arg4 = (float)jarg4;
73181   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73182   if (!arg5) {
73183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73184     return 0;
73185   }
73186   {
73187     try {
73188       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73189     } catch (std::out_of_range& e) {
73190       {
73191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73192       };
73193     } catch (std::exception& e) {
73194       {
73195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73196       };
73197     } catch (...) {
73198       {
73199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73200       };
73201     }
73202   }
73203   jresult = result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73209   float jresult ;
73210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73211   float arg2 ;
73212   float arg3 ;
73213   float arg4 ;
73214   float arg5 ;
73215   float result;
73216
73217   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73218   arg2 = (float)jarg2;
73219   arg3 = (float)jarg3;
73220   arg4 = (float)jarg4;
73221   arg5 = (float)jarg5;
73222   {
73223     try {
73224       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73225     } catch (std::out_of_range& e) {
73226       {
73227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73228       };
73229     } catch (std::exception& e) {
73230       {
73231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73232       };
73233     } catch (...) {
73234       {
73235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73236       };
73237     }
73238   }
73239   jresult = result;
73240   return jresult;
73241 }
73242
73243
73244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73245   float jresult ;
73246   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73247   float arg2 ;
73248   float arg3 ;
73249   float arg4 ;
73250   float result;
73251
73252   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73253   arg2 = (float)jarg2;
73254   arg3 = (float)jarg3;
73255   arg4 = (float)jarg4;
73256   {
73257     try {
73258       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73259     } catch (std::out_of_range& e) {
73260       {
73261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (std::exception& e) {
73264       {
73265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73270       };
73271     }
73272   }
73273   jresult = result;
73274   return jresult;
73275 }
73276
73277
73278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73279   float jresult ;
73280   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73281   float arg2 ;
73282   float arg3 ;
73283   float result;
73284
73285   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73286   arg2 = (float)jarg2;
73287   arg3 = (float)jarg3;
73288   {
73289     try {
73290       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73291     } catch (std::out_of_range& e) {
73292       {
73293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73294       };
73295     } catch (std::exception& e) {
73296       {
73297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73298       };
73299     } catch (...) {
73300       {
73301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73302       };
73303     }
73304   }
73305   jresult = result;
73306   return jresult;
73307 }
73308
73309
73310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73311   float jresult ;
73312   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73313   float arg2 ;
73314   float result;
73315
73316   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73317   arg2 = (float)jarg2;
73318   {
73319     try {
73320       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73321     } catch (std::out_of_range& e) {
73322       {
73323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (std::exception& e) {
73326       {
73327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73328       };
73329     } catch (...) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73332       };
73333     }
73334   }
73335   jresult = result;
73336   return jresult;
73337 }
73338
73339
73340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73341   float jresult ;
73342   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73343   float arg2 ;
73344   float arg3 ;
73345   float arg4 ;
73346   float arg5 ;
73347   Dali::Toolkit::ClampState *arg6 = 0 ;
73348   float result;
73349
73350   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73351   arg2 = (float)jarg2;
73352   arg3 = (float)jarg3;
73353   arg4 = (float)jarg4;
73354   arg5 = (float)jarg5;
73355   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73356   if (!arg6) {
73357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73358     return 0;
73359   }
73360   {
73361     try {
73362       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73363     } catch (std::out_of_range& e) {
73364       {
73365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73366       };
73367     } catch (std::exception& e) {
73368       {
73369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73370       };
73371     } catch (...) {
73372       {
73373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73374       };
73375     }
73376   }
73377   jresult = result;
73378   return jresult;
73379 }
73380
73381
73382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73383   void * jresult ;
73384   Dali::Toolkit::DefaultRuler *result = 0 ;
73385
73386   {
73387     try {
73388       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73389     } catch (std::out_of_range& e) {
73390       {
73391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (std::exception& e) {
73394       {
73395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73396       };
73397     } catch (...) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73400       };
73401     }
73402   }
73403   jresult = (void *)result;
73404   return jresult;
73405 }
73406
73407
73408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73409   float jresult ;
73410   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73411   float arg2 ;
73412   float arg3 ;
73413   float result;
73414
73415   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73416   arg2 = (float)jarg2;
73417   arg3 = (float)jarg3;
73418   {
73419     try {
73420       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73421     } catch (std::out_of_range& e) {
73422       {
73423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73424       };
73425     } catch (std::exception& e) {
73426       {
73427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73428       };
73429     } catch (...) {
73430       {
73431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73432       };
73433     }
73434   }
73435   jresult = result;
73436   return jresult;
73437 }
73438
73439
73440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73441   float jresult ;
73442   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73443   unsigned int arg2 ;
73444   unsigned int *arg3 = 0 ;
73445   bool arg4 ;
73446   float result;
73447
73448   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73449   arg2 = (unsigned int)jarg2;
73450   arg3 = (unsigned int *)jarg3;
73451   arg4 = jarg4 ? true : false;
73452   {
73453     try {
73454       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73455     } catch (std::out_of_range& e) {
73456       {
73457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73458       };
73459     } catch (std::exception& e) {
73460       {
73461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73462       };
73463     } catch (...) {
73464       {
73465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73466       };
73467     }
73468   }
73469   jresult = result;
73470   return jresult;
73471 }
73472
73473
73474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73475   unsigned int jresult ;
73476   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73477   float arg2 ;
73478   bool arg3 ;
73479   unsigned int result;
73480
73481   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73482   arg2 = (float)jarg2;
73483   arg3 = jarg3 ? true : false;
73484   {
73485     try {
73486       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73487     } catch (std::out_of_range& e) {
73488       {
73489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (std::exception& e) {
73492       {
73493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73498       };
73499     }
73500   }
73501   jresult = result;
73502   return jresult;
73503 }
73504
73505
73506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73507   unsigned int jresult ;
73508   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73509   unsigned int result;
73510
73511   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73512   {
73513     try {
73514       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73515     } catch (std::out_of_range& e) {
73516       {
73517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (std::exception& e) {
73520       {
73521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73526       };
73527     }
73528   }
73529   jresult = result;
73530   return jresult;
73531 }
73532
73533
73534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73535   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73536
73537   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73538   {
73539     try {
73540       delete arg1;
73541     } catch (std::out_of_range& e) {
73542       {
73543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73544       };
73545     } catch (std::exception& e) {
73546       {
73547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73548       };
73549     } catch (...) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73552       };
73553     }
73554   }
73555 }
73556
73557
73558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73559   void * jresult ;
73560   float arg1 ;
73561   Dali::Toolkit::FixedRuler *result = 0 ;
73562
73563   arg1 = (float)jarg1;
73564   {
73565     try {
73566       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73567     } catch (std::out_of_range& e) {
73568       {
73569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (std::exception& e) {
73572       {
73573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73578       };
73579     }
73580   }
73581   jresult = (void *)result;
73582   return jresult;
73583 }
73584
73585
73586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73587   void * jresult ;
73588   Dali::Toolkit::FixedRuler *result = 0 ;
73589
73590   {
73591     try {
73592       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73593     } catch (std::out_of_range& e) {
73594       {
73595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73596       };
73597     } catch (std::exception& e) {
73598       {
73599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73600       };
73601     } catch (...) {
73602       {
73603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73604       };
73605     }
73606   }
73607   jresult = (void *)result;
73608   return jresult;
73609 }
73610
73611
73612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73613   float jresult ;
73614   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73615   float arg2 ;
73616   float arg3 ;
73617   float result;
73618
73619   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73620   arg2 = (float)jarg2;
73621   arg3 = (float)jarg3;
73622   {
73623     try {
73624       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73625     } catch (std::out_of_range& e) {
73626       {
73627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73628       };
73629     } catch (std::exception& e) {
73630       {
73631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73632       };
73633     } catch (...) {
73634       {
73635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73636       };
73637     }
73638   }
73639   jresult = result;
73640   return jresult;
73641 }
73642
73643
73644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73645   float jresult ;
73646   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73647   unsigned int arg2 ;
73648   unsigned int *arg3 = 0 ;
73649   bool arg4 ;
73650   float result;
73651
73652   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73653   arg2 = (unsigned int)jarg2;
73654   arg3 = (unsigned int *)jarg3;
73655   arg4 = jarg4 ? true : false;
73656   {
73657     try {
73658       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73659     } catch (std::out_of_range& e) {
73660       {
73661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73662       };
73663     } catch (std::exception& e) {
73664       {
73665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73666       };
73667     } catch (...) {
73668       {
73669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73670       };
73671     }
73672   }
73673   jresult = result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73679   unsigned int jresult ;
73680   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73681   float arg2 ;
73682   bool arg3 ;
73683   unsigned int result;
73684
73685   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73686   arg2 = (float)jarg2;
73687   arg3 = jarg3 ? true : false;
73688   {
73689     try {
73690       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73691     } catch (std::out_of_range& e) {
73692       {
73693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73694       };
73695     } catch (std::exception& e) {
73696       {
73697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73698       };
73699     } catch (...) {
73700       {
73701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73702       };
73703     }
73704   }
73705   jresult = result;
73706   return jresult;
73707 }
73708
73709
73710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73711   unsigned int jresult ;
73712   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73713   unsigned int result;
73714
73715   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73716   {
73717     try {
73718       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73719     } catch (std::out_of_range& e) {
73720       {
73721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73722       };
73723     } catch (std::exception& e) {
73724       {
73725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73726       };
73727     } catch (...) {
73728       {
73729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73730       };
73731     }
73732   }
73733   jresult = result;
73734   return jresult;
73735 }
73736
73737
73738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73739   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73740
73741   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73742   {
73743     try {
73744       delete arg1;
73745     } catch (std::out_of_range& e) {
73746       {
73747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73748       };
73749     } catch (std::exception& e) {
73750       {
73751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73752       };
73753     } catch (...) {
73754       {
73755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73756       };
73757     }
73758   }
73759 }
73760
73761
73762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73763   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73764   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73765
73766   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73767   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73768   if (arg1) (arg1)->scale = *arg2;
73769 }
73770
73771
73772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73773   void * jresult ;
73774   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73775   Dali::Toolkit::ClampState2D *result = 0 ;
73776
73777   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73778   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73779   jresult = (void *)result;
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73785   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73786   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73787
73788   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73789   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73790   if (arg1) (arg1)->position = *arg2;
73791 }
73792
73793
73794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73795   void * jresult ;
73796   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73797   Dali::Toolkit::ClampState2D *result = 0 ;
73798
73799   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73800   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73801   jresult = (void *)result;
73802   return jresult;
73803 }
73804
73805
73806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73807   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73808   Dali::Toolkit::ClampState arg2 ;
73809
73810   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73811   arg2 = (Dali::Toolkit::ClampState)jarg2;
73812   if (arg1) (arg1)->rotation = arg2;
73813 }
73814
73815
73816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73817   int jresult ;
73818   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73819   Dali::Toolkit::ClampState result;
73820
73821   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73822   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73823   jresult = (int)result;
73824   return jresult;
73825 }
73826
73827
73828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73829   void * jresult ;
73830   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73831
73832   {
73833     try {
73834       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73835     } catch (std::out_of_range& e) {
73836       {
73837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73838       };
73839     } catch (std::exception& e) {
73840       {
73841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73842       };
73843     } catch (...) {
73844       {
73845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73846       };
73847     }
73848   }
73849   jresult = (void *)result;
73850   return jresult;
73851 }
73852
73853
73854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73855   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73856
73857   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73858   {
73859     try {
73860       delete arg1;
73861     } catch (std::out_of_range& e) {
73862       {
73863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73864       };
73865     } catch (std::exception& e) {
73866       {
73867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73868       };
73869     } catch (...) {
73870       {
73871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73872       };
73873     }
73874   }
73875 }
73876
73877
73878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73879   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73880   Dali::Toolkit::SnapType arg2 ;
73881
73882   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73883   arg2 = (Dali::Toolkit::SnapType)jarg2;
73884   if (arg1) (arg1)->type = arg2;
73885 }
73886
73887
73888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73889   int jresult ;
73890   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73891   Dali::Toolkit::SnapType result;
73892
73893   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73894   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73895   jresult = (int)result;
73896   return jresult;
73897 }
73898
73899
73900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73901   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73902   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73903
73904   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73905   arg2 = (Dali::Vector2 *)jarg2;
73906   if (arg1) (arg1)->position = *arg2;
73907 }
73908
73909
73910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73911   void * jresult ;
73912   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73913   Dali::Vector2 *result = 0 ;
73914
73915   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73916   result = (Dali::Vector2 *)& ((arg1)->position);
73917   jresult = (void *)result;
73918   return jresult;
73919 }
73920
73921
73922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73923   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73924   float arg2 ;
73925
73926   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73927   arg2 = (float)jarg2;
73928   if (arg1) (arg1)->duration = arg2;
73929 }
73930
73931
73932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73933   float jresult ;
73934   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73935   float result;
73936
73937   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73938   result = (float) ((arg1)->duration);
73939   jresult = result;
73940   return jresult;
73941 }
73942
73943
73944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73945   void * jresult ;
73946   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73947
73948   {
73949     try {
73950       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73951     } catch (std::out_of_range& e) {
73952       {
73953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73954       };
73955     } catch (std::exception& e) {
73956       {
73957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73958       };
73959     } catch (...) {
73960       {
73961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73962       };
73963     }
73964   }
73965   jresult = (void *)result;
73966   return jresult;
73967 }
73968
73969
73970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73971   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73972
73973   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73974   {
73975     try {
73976       delete arg1;
73977     } catch (std::out_of_range& e) {
73978       {
73979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73980       };
73981     } catch (std::exception& e) {
73982       {
73983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73984       };
73985     } catch (...) {
73986       {
73987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73988       };
73989     }
73990   }
73991 }
73992
73993
73994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73995   int jresult ;
73996   int result;
73997
73998   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73999   jresult = (int)result;
74000   return jresult;
74001 }
74002
74003
74004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74005   int jresult ;
74006   int result;
74007
74008   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74009   jresult = (int)result;
74010   return jresult;
74011 }
74012
74013
74014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74015   int jresult ;
74016   int result;
74017
74018   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74019   jresult = (int)result;
74020   return jresult;
74021 }
74022
74023
74024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74025   int jresult ;
74026   int result;
74027
74028   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74029   jresult = (int)result;
74030   return jresult;
74031 }
74032
74033
74034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74035   int jresult ;
74036   int result;
74037
74038   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
74039   jresult = (int)result;
74040   return jresult;
74041 }
74042
74043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74044   int jresult ;
74045   int result;
74046
74047   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74048   jresult = (int)result;
74049   return jresult;
74050 }
74051
74052
74053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74054   int jresult ;
74055   int result;
74056
74057   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74058   jresult = (int)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74064   int jresult ;
74065   int result;
74066
74067   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74068   jresult = (int)result;
74069   return jresult;
74070 }
74071
74072
74073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74074   int jresult ;
74075   int result;
74076
74077   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74078   jresult = (int)result;
74079   return jresult;
74080 }
74081
74082
74083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74084   int jresult ;
74085   int result;
74086
74087   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74088   jresult = (int)result;
74089   return jresult;
74090 }
74091
74092
74093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74094   int jresult ;
74095   int result;
74096
74097   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74098   jresult = (int)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74104   int jresult ;
74105   int result;
74106
74107   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74108   jresult = (int)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74114   int jresult ;
74115   int result;
74116
74117   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74118   jresult = (int)result;
74119   return jresult;
74120 }
74121
74122
74123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74124   int jresult ;
74125   int result;
74126
74127   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74128   jresult = (int)result;
74129   return jresult;
74130 }
74131
74132
74133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74134   int jresult ;
74135   int result;
74136
74137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74138   jresult = (int)result;
74139   return jresult;
74140 }
74141
74142
74143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74144   int jresult ;
74145   int result;
74146
74147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74148   jresult = (int)result;
74149   return jresult;
74150 }
74151
74152
74153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74154   int jresult ;
74155   int result;
74156
74157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74158   jresult = (int)result;
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74164   int jresult ;
74165   int result;
74166
74167   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74168   jresult = (int)result;
74169   return jresult;
74170 }
74171
74172
74173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74174   int jresult ;
74175   int result;
74176
74177   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74178   jresult = (int)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74184   int jresult ;
74185   int result;
74186
74187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74188   jresult = (int)result;
74189   return jresult;
74190 }
74191
74192
74193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74194   int jresult ;
74195   int result;
74196
74197   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74198   jresult = (int)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74204   int jresult ;
74205   int result;
74206
74207   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74208   jresult = (int)result;
74209   return jresult;
74210 }
74211
74212
74213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74214   int jresult ;
74215   int result;
74216
74217   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74218   jresult = (int)result;
74219   return jresult;
74220 }
74221
74222
74223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74224   int jresult ;
74225   int result;
74226
74227   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74228   jresult = (int)result;
74229   return jresult;
74230 }
74231
74232
74233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74234   int jresult ;
74235   int result;
74236
74237   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74238   jresult = (int)result;
74239   return jresult;
74240 }
74241
74242
74243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74244   int jresult ;
74245   int result;
74246
74247   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74248   jresult = (int)result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74254   void * jresult ;
74255   Dali::Toolkit::ScrollView::Property *result = 0 ;
74256
74257   {
74258     try {
74259       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74260     } catch (std::out_of_range& e) {
74261       {
74262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74263       };
74264     } catch (std::exception& e) {
74265       {
74266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74267       };
74268     } catch (...) {
74269       {
74270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74271       };
74272     }
74273   }
74274   jresult = (void *)result;
74275   return jresult;
74276 }
74277
74278
74279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74280   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74281
74282   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74283   {
74284     try {
74285       delete arg1;
74286     } catch (std::out_of_range& e) {
74287       {
74288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74289       };
74290     } catch (std::exception& e) {
74291       {
74292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74293       };
74294     } catch (...) {
74295       {
74296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74297       };
74298     }
74299   }
74300 }
74301
74302
74303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74304   void * jresult ;
74305   Dali::Toolkit::ScrollView *result = 0 ;
74306
74307   {
74308     try {
74309       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74310     } catch (std::out_of_range& e) {
74311       {
74312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (std::exception& e) {
74315       {
74316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74317       };
74318     } catch (...) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74321       };
74322     }
74323   }
74324   jresult = (void *)result;
74325   return jresult;
74326 }
74327
74328
74329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74330   void * jresult ;
74331   Dali::Toolkit::ScrollView *arg1 = 0 ;
74332   Dali::Toolkit::ScrollView *result = 0 ;
74333
74334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74335   if (!arg1) {
74336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74337     return 0;
74338   }
74339   {
74340     try {
74341       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74342     } catch (std::out_of_range& e) {
74343       {
74344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74345       };
74346     } catch (std::exception& e) {
74347       {
74348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74349       };
74350     } catch (...) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74353       };
74354     }
74355   }
74356   jresult = (void *)result;
74357   return jresult;
74358 }
74359
74360
74361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74362   void * jresult ;
74363   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74364   Dali::Toolkit::ScrollView *arg2 = 0 ;
74365   Dali::Toolkit::ScrollView *result = 0 ;
74366
74367   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74368   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74369   if (!arg2) {
74370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74371     return 0;
74372   }
74373   {
74374     try {
74375       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74376     } catch (std::out_of_range& e) {
74377       {
74378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74379       };
74380     } catch (std::exception& e) {
74381       {
74382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74387       };
74388     }
74389   }
74390   jresult = (void *)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74396   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74397
74398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74399   {
74400     try {
74401       delete arg1;
74402     } catch (std::out_of_range& e) {
74403       {
74404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74405       };
74406     } catch (std::exception& e) {
74407       {
74408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74409       };
74410     } catch (...) {
74411       {
74412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74413       };
74414     }
74415   }
74416 }
74417
74418
74419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74420   void * jresult ;
74421   Dali::Toolkit::ScrollView result;
74422
74423   {
74424     try {
74425       result = Dali::Toolkit::ScrollView::New();
74426     } catch (std::out_of_range& e) {
74427       {
74428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74429       };
74430     } catch (std::exception& e) {
74431       {
74432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74433       };
74434     } catch (...) {
74435       {
74436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74437       };
74438     }
74439   }
74440   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74441   return jresult;
74442 }
74443
74444
74445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74446   void * jresult ;
74447   Dali::BaseHandle arg1 ;
74448   Dali::BaseHandle *argp1 ;
74449   Dali::Toolkit::ScrollView result;
74450
74451   argp1 = (Dali::BaseHandle *)jarg1;
74452   if (!argp1) {
74453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74454     return 0;
74455   }
74456   arg1 = *argp1;
74457   {
74458     try {
74459       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74460     } catch (std::out_of_range& e) {
74461       {
74462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74463       };
74464     } catch (std::exception& e) {
74465       {
74466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74467       };
74468     } catch (...) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74471       };
74472     }
74473   }
74474   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74475   return jresult;
74476 }
74477
74478
74479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74480   void * jresult ;
74481   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74482   Dali::AlphaFunction result;
74483
74484   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74485   {
74486     try {
74487       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74488     } catch (std::out_of_range& e) {
74489       {
74490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74491       };
74492     } catch (std::exception& e) {
74493       {
74494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74495       };
74496     } catch (...) {
74497       {
74498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74499       };
74500     }
74501   }
74502   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74508   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74509   Dali::AlphaFunction arg2 ;
74510   Dali::AlphaFunction *argp2 ;
74511
74512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74513   argp2 = (Dali::AlphaFunction *)jarg2;
74514   if (!argp2) {
74515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74516     return ;
74517   }
74518   arg2 = *argp2;
74519   {
74520     try {
74521       (arg1)->SetScrollSnapAlphaFunction(arg2);
74522     } catch (std::out_of_range& e) {
74523       {
74524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74525       };
74526     } catch (std::exception& e) {
74527       {
74528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74529       };
74530     } catch (...) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74533       };
74534     }
74535   }
74536 }
74537
74538
74539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74540   void * jresult ;
74541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74542   Dali::AlphaFunction result;
74543
74544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74545   {
74546     try {
74547       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
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 = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74563   return jresult;
74564 }
74565
74566
74567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74568   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74569   Dali::AlphaFunction arg2 ;
74570   Dali::AlphaFunction *argp2 ;
74571
74572   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74573   argp2 = (Dali::AlphaFunction *)jarg2;
74574   if (!argp2) {
74575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74576     return ;
74577   }
74578   arg2 = *argp2;
74579   {
74580     try {
74581       (arg1)->SetScrollFlickAlphaFunction(arg2);
74582     } catch (std::out_of_range& e) {
74583       {
74584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74585       };
74586     } catch (std::exception& e) {
74587       {
74588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74589       };
74590     } catch (...) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74593       };
74594     }
74595   }
74596 }
74597
74598
74599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74600   float jresult ;
74601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74602   float result;
74603
74604   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74605   {
74606     try {
74607       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74608     } catch (std::out_of_range& e) {
74609       {
74610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74611       };
74612     } catch (std::exception& e) {
74613       {
74614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74615       };
74616     } catch (...) {
74617       {
74618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74619       };
74620     }
74621   }
74622   jresult = result;
74623   return jresult;
74624 }
74625
74626
74627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74628   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74629   float arg2 ;
74630
74631   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74632   arg2 = (float)jarg2;
74633   {
74634     try {
74635       (arg1)->SetScrollSnapDuration(arg2);
74636     } catch (std::out_of_range& e) {
74637       {
74638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74639       };
74640     } catch (std::exception& e) {
74641       {
74642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74643       };
74644     } catch (...) {
74645       {
74646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74647       };
74648     }
74649   }
74650 }
74651
74652
74653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74654   float jresult ;
74655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74656   float result;
74657
74658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74659   {
74660     try {
74661       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74662     } catch (std::out_of_range& e) {
74663       {
74664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (std::exception& e) {
74667       {
74668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74673       };
74674     }
74675   }
74676   jresult = result;
74677   return jresult;
74678 }
74679
74680
74681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74683   float arg2 ;
74684
74685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74686   arg2 = (float)jarg2;
74687   {
74688     try {
74689       (arg1)->SetScrollFlickDuration(arg2);
74690     } catch (std::out_of_range& e) {
74691       {
74692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74693       };
74694     } catch (std::exception& e) {
74695       {
74696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74697       };
74698     } catch (...) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74701       };
74702     }
74703   }
74704 }
74705
74706
74707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74708   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74709   Dali::Toolkit::RulerPtr arg2 ;
74710   Dali::Toolkit::RulerPtr *argp2 ;
74711
74712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74713   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74714   if (!argp2) {
74715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74716     return ;
74717   }
74718   arg2 = *argp2;
74719   {
74720     try {
74721       (arg1)->SetRulerX(arg2);
74722     } catch (std::out_of_range& e) {
74723       {
74724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74725       };
74726     } catch (std::exception& e) {
74727       {
74728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74729       };
74730     } catch (...) {
74731       {
74732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74733       };
74734     }
74735   }
74736 }
74737
74738
74739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74740   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74741   Dali::Toolkit::RulerPtr arg2 ;
74742   Dali::Toolkit::RulerPtr *argp2 ;
74743
74744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74745   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74746   if (!argp2) {
74747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74748     return ;
74749   }
74750   arg2 = *argp2;
74751   {
74752     try {
74753       (arg1)->SetRulerY(arg2);
74754     } catch (std::out_of_range& e) {
74755       {
74756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74757       };
74758     } catch (std::exception& e) {
74759       {
74760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74761       };
74762     } catch (...) {
74763       {
74764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74765       };
74766     }
74767   }
74768 }
74769
74770
74771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74773   bool arg2 ;
74774
74775   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74776   arg2 = jarg2 ? true : false;
74777   {
74778     try {
74779       (arg1)->SetScrollSensitive(arg2);
74780     } catch (std::out_of_range& e) {
74781       {
74782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74783       };
74784     } catch (std::exception& e) {
74785       {
74786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74787       };
74788     } catch (...) {
74789       {
74790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74791       };
74792     }
74793   }
74794 }
74795
74796
74797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74798   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74799   float arg2 ;
74800   float arg3 ;
74801
74802   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74803   arg2 = (float)jarg2;
74804   arg3 = (float)jarg3;
74805   {
74806     try {
74807       (arg1)->SetMaxOvershoot(arg2,arg3);
74808     } catch (std::out_of_range& e) {
74809       {
74810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74811       };
74812     } catch (std::exception& e) {
74813       {
74814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74815       };
74816     } catch (...) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74819       };
74820     }
74821   }
74822 }
74823
74824
74825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74827   Dali::AlphaFunction arg2 ;
74828   Dali::AlphaFunction *argp2 ;
74829
74830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74831   argp2 = (Dali::AlphaFunction *)jarg2;
74832   if (!argp2) {
74833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74834     return ;
74835   }
74836   arg2 = *argp2;
74837   {
74838     try {
74839       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74840     } catch (std::out_of_range& e) {
74841       {
74842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74843       };
74844     } catch (std::exception& e) {
74845       {
74846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74847       };
74848     } catch (...) {
74849       {
74850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74851       };
74852     }
74853   }
74854 }
74855
74856
74857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74859   float arg2 ;
74860
74861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74862   arg2 = (float)jarg2;
74863   {
74864     try {
74865       (arg1)->SetSnapOvershootDuration(arg2);
74866     } catch (std::out_of_range& e) {
74867       {
74868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74869       };
74870     } catch (std::exception& e) {
74871       {
74872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74873       };
74874     } catch (...) {
74875       {
74876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74877       };
74878     }
74879   }
74880 }
74881
74882
74883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74885   bool arg2 ;
74886
74887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74888   arg2 = jarg2 ? true : false;
74889   {
74890     try {
74891       (arg1)->SetActorAutoSnap(arg2);
74892     } catch (std::out_of_range& e) {
74893       {
74894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74895       };
74896     } catch (std::exception& e) {
74897       {
74898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74899       };
74900     } catch (...) {
74901       {
74902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74903       };
74904     }
74905   }
74906 }
74907
74908
74909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74911   bool arg2 ;
74912
74913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74914   arg2 = jarg2 ? true : false;
74915   {
74916     try {
74917       (arg1)->SetWrapMode(arg2);
74918     } catch (std::out_of_range& e) {
74919       {
74920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74921       };
74922     } catch (std::exception& e) {
74923       {
74924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74925       };
74926     } catch (...) {
74927       {
74928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74929       };
74930     }
74931   }
74932 }
74933
74934
74935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74936   int jresult ;
74937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74938   int result;
74939
74940   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74941   {
74942     try {
74943       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74944     } catch (std::out_of_range& e) {
74945       {
74946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74947       };
74948     } catch (std::exception& e) {
74949       {
74950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74951       };
74952     } catch (...) {
74953       {
74954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74955       };
74956     }
74957   }
74958   jresult = result;
74959   return jresult;
74960 }
74961
74962
74963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74965   int arg2 ;
74966
74967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74968   arg2 = (int)jarg2;
74969   {
74970     try {
74971       (arg1)->SetScrollUpdateDistance(arg2);
74972     } catch (std::out_of_range& e) {
74973       {
74974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74975       };
74976     } catch (std::exception& e) {
74977       {
74978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74979       };
74980     } catch (...) {
74981       {
74982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74983       };
74984     }
74985   }
74986 }
74987
74988
74989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74990   unsigned int jresult ;
74991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74992   bool result;
74993
74994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74995   {
74996     try {
74997       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74998     } catch (std::out_of_range& e) {
74999       {
75000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75001       };
75002     } catch (std::exception& e) {
75003       {
75004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75005       };
75006     } catch (...) {
75007       {
75008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75009       };
75010     }
75011   }
75012   jresult = result;
75013   return jresult;
75014 }
75015
75016
75017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75018   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75019   bool arg2 ;
75020
75021   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75022   arg2 = jarg2 ? true : false;
75023   {
75024     try {
75025       (arg1)->SetAxisAutoLock(arg2);
75026     } catch (std::out_of_range& e) {
75027       {
75028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75029       };
75030     } catch (std::exception& e) {
75031       {
75032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75033       };
75034     } catch (...) {
75035       {
75036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75037       };
75038     }
75039   }
75040 }
75041
75042
75043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75044   float jresult ;
75045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75046   float result;
75047
75048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75049   {
75050     try {
75051       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75052     } catch (std::out_of_range& e) {
75053       {
75054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75055       };
75056     } catch (std::exception& e) {
75057       {
75058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75059       };
75060     } catch (...) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75063       };
75064     }
75065   }
75066   jresult = result;
75067   return jresult;
75068 }
75069
75070
75071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75072   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75073   float arg2 ;
75074
75075   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75076   arg2 = (float)jarg2;
75077   {
75078     try {
75079       (arg1)->SetAxisAutoLockGradient(arg2);
75080     } catch (std::out_of_range& e) {
75081       {
75082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75083       };
75084     } catch (std::exception& e) {
75085       {
75086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75087       };
75088     } catch (...) {
75089       {
75090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75091       };
75092     }
75093   }
75094 }
75095
75096
75097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75098   float jresult ;
75099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75100   float result;
75101
75102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75103   {
75104     try {
75105       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75106     } catch (std::out_of_range& e) {
75107       {
75108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75109       };
75110     } catch (std::exception& e) {
75111       {
75112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75113       };
75114     } catch (...) {
75115       {
75116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75117       };
75118     }
75119   }
75120   jresult = result;
75121   return jresult;
75122 }
75123
75124
75125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75127   float arg2 ;
75128
75129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75130   arg2 = (float)jarg2;
75131   {
75132     try {
75133       (arg1)->SetFrictionCoefficient(arg2);
75134     } catch (std::out_of_range& e) {
75135       {
75136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75137       };
75138     } catch (std::exception& e) {
75139       {
75140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75141       };
75142     } catch (...) {
75143       {
75144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75145       };
75146     }
75147   }
75148 }
75149
75150
75151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75152   float jresult ;
75153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75154   float result;
75155
75156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75157   {
75158     try {
75159       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75160     } catch (std::out_of_range& e) {
75161       {
75162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75163       };
75164     } catch (std::exception& e) {
75165       {
75166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75167       };
75168     } catch (...) {
75169       {
75170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75171       };
75172     }
75173   }
75174   jresult = result;
75175   return jresult;
75176 }
75177
75178
75179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75181   float arg2 ;
75182
75183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75184   arg2 = (float)jarg2;
75185   {
75186     try {
75187       (arg1)->SetFlickSpeedCoefficient(arg2);
75188     } catch (std::out_of_range& e) {
75189       {
75190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75191       };
75192     } catch (std::exception& e) {
75193       {
75194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75199       };
75200     }
75201   }
75202 }
75203
75204
75205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75206   void * jresult ;
75207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75208   Dali::Vector2 result;
75209
75210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75211   {
75212     try {
75213       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75214     } catch (std::out_of_range& e) {
75215       {
75216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75217       };
75218     } catch (std::exception& e) {
75219       {
75220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (...) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75225       };
75226     }
75227   }
75228   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75229   return jresult;
75230 }
75231
75232
75233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75235   Dali::Vector2 *arg2 = 0 ;
75236
75237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75238   arg2 = (Dali::Vector2 *)jarg2;
75239   if (!arg2) {
75240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75241     return ;
75242   }
75243   {
75244     try {
75245       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75246     } catch (std::out_of_range& e) {
75247       {
75248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75249       };
75250     } catch (std::exception& e) {
75251       {
75252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75257       };
75258     }
75259   }
75260 }
75261
75262
75263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75264   float jresult ;
75265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75266   float result;
75267
75268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75269   {
75270     try {
75271       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75272     } catch (std::out_of_range& e) {
75273       {
75274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75275       };
75276     } catch (std::exception& e) {
75277       {
75278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75279       };
75280     } catch (...) {
75281       {
75282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75283       };
75284     }
75285   }
75286   jresult = result;
75287   return jresult;
75288 }
75289
75290
75291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75292   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75293   float arg2 ;
75294
75295   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75296   arg2 = (float)jarg2;
75297   {
75298     try {
75299       (arg1)->SetMinimumSpeedForFlick(arg2);
75300     } catch (std::out_of_range& e) {
75301       {
75302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75303       };
75304     } catch (std::exception& e) {
75305       {
75306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75307       };
75308     } catch (...) {
75309       {
75310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75311       };
75312     }
75313   }
75314 }
75315
75316
75317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75318   float jresult ;
75319   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75320   float result;
75321
75322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75323   {
75324     try {
75325       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75326     } catch (std::out_of_range& e) {
75327       {
75328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75329       };
75330     } catch (std::exception& e) {
75331       {
75332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75337       };
75338     }
75339   }
75340   jresult = result;
75341   return jresult;
75342 }
75343
75344
75345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75346   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75347   float arg2 ;
75348
75349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75350   arg2 = (float)jarg2;
75351   {
75352     try {
75353       (arg1)->SetMaxFlickSpeed(arg2);
75354     } catch (std::out_of_range& e) {
75355       {
75356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75357       };
75358     } catch (std::exception& e) {
75359       {
75360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75361       };
75362     } catch (...) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75365       };
75366     }
75367   }
75368 }
75369
75370
75371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75372   void * jresult ;
75373   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75374   Dali::Vector2 result;
75375
75376   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75377   {
75378     try {
75379       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75380     } catch (std::out_of_range& e) {
75381       {
75382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75383       };
75384     } catch (std::exception& e) {
75385       {
75386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75387       };
75388     } catch (...) {
75389       {
75390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75391       };
75392     }
75393   }
75394   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75395   return jresult;
75396 }
75397
75398
75399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75401   Dali::Vector2 arg2 ;
75402   Dali::Vector2 *argp2 ;
75403
75404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75405   argp2 = (Dali::Vector2 *)jarg2;
75406   if (!argp2) {
75407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75408     return ;
75409   }
75410   arg2 = *argp2;
75411   {
75412     try {
75413       (arg1)->SetWheelScrollDistanceStep(arg2);
75414     } catch (std::out_of_range& e) {
75415       {
75416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75417       };
75418     } catch (std::exception& e) {
75419       {
75420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75421       };
75422     } catch (...) {
75423       {
75424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75425       };
75426     }
75427   }
75428 }
75429
75430
75431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75432   void * jresult ;
75433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75434   Dali::Vector2 result;
75435
75436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75437   {
75438     try {
75439       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75440     } catch (std::out_of_range& e) {
75441       {
75442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75443       };
75444     } catch (std::exception& e) {
75445       {
75446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75447       };
75448     } catch (...) {
75449       {
75450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75451       };
75452     }
75453   }
75454   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75455   return jresult;
75456 }
75457
75458
75459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75460   unsigned int jresult ;
75461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75462   unsigned int result;
75463
75464   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75465   {
75466     try {
75467       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75468     } catch (std::out_of_range& e) {
75469       {
75470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75471       };
75472     } catch (std::exception& e) {
75473       {
75474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75475       };
75476     } catch (...) {
75477       {
75478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75479       };
75480     }
75481   }
75482   jresult = result;
75483   return jresult;
75484 }
75485
75486
75487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75489   Dali::Vector2 *arg2 = 0 ;
75490
75491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75492   arg2 = (Dali::Vector2 *)jarg2;
75493   if (!arg2) {
75494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75495     return ;
75496   }
75497   {
75498     try {
75499       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75500     } catch (std::out_of_range& e) {
75501       {
75502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75503       };
75504     } catch (std::exception& e) {
75505       {
75506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75507       };
75508     } catch (...) {
75509       {
75510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75511       };
75512     }
75513   }
75514 }
75515
75516
75517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75519   Dali::Vector2 *arg2 = 0 ;
75520   float arg3 ;
75521
75522   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75523   arg2 = (Dali::Vector2 *)jarg2;
75524   if (!arg2) {
75525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75526     return ;
75527   }
75528   arg3 = (float)jarg3;
75529   {
75530     try {
75531       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75532     } catch (std::out_of_range& e) {
75533       {
75534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75535       };
75536     } catch (std::exception& e) {
75537       {
75538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75539       };
75540     } catch (...) {
75541       {
75542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75543       };
75544     }
75545   }
75546 }
75547
75548
75549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75551   Dali::Vector2 *arg2 = 0 ;
75552   float arg3 ;
75553   Dali::AlphaFunction arg4 ;
75554   Dali::AlphaFunction *argp4 ;
75555
75556   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75557   arg2 = (Dali::Vector2 *)jarg2;
75558   if (!arg2) {
75559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75560     return ;
75561   }
75562   arg3 = (float)jarg3;
75563   argp4 = (Dali::AlphaFunction *)jarg4;
75564   if (!argp4) {
75565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75566     return ;
75567   }
75568   arg4 = *argp4;
75569   {
75570     try {
75571       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75572     } catch (std::out_of_range& e) {
75573       {
75574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75575       };
75576     } catch (std::exception& e) {
75577       {
75578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75579       };
75580     } catch (...) {
75581       {
75582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75583       };
75584     }
75585   }
75586 }
75587
75588
75589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75590   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75591   Dali::Vector2 *arg2 = 0 ;
75592   float arg3 ;
75593   Dali::Toolkit::DirectionBias arg4 ;
75594   Dali::Toolkit::DirectionBias arg5 ;
75595
75596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75597   arg2 = (Dali::Vector2 *)jarg2;
75598   if (!arg2) {
75599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75600     return ;
75601   }
75602   arg3 = (float)jarg3;
75603   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75604   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75605   {
75606     try {
75607       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75608     } catch (std::out_of_range& e) {
75609       {
75610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75611       };
75612     } catch (std::exception& e) {
75613       {
75614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75615       };
75616     } catch (...) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75619       };
75620     }
75621   }
75622 }
75623
75624
75625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75627   Dali::Vector2 *arg2 = 0 ;
75628   float arg3 ;
75629   Dali::AlphaFunction arg4 ;
75630   Dali::Toolkit::DirectionBias arg5 ;
75631   Dali::Toolkit::DirectionBias arg6 ;
75632   Dali::AlphaFunction *argp4 ;
75633
75634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75635   arg2 = (Dali::Vector2 *)jarg2;
75636   if (!arg2) {
75637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75638     return ;
75639   }
75640   arg3 = (float)jarg3;
75641   argp4 = (Dali::AlphaFunction *)jarg4;
75642   if (!argp4) {
75643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75644     return ;
75645   }
75646   arg4 = *argp4;
75647   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75648   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75649   {
75650     try {
75651       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75652     } catch (std::out_of_range& e) {
75653       {
75654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75655       };
75656     } catch (std::exception& e) {
75657       {
75658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75659       };
75660     } catch (...) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75663       };
75664     }
75665   }
75666 }
75667
75668
75669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75670   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75671   unsigned int arg2 ;
75672
75673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75674   arg2 = (unsigned int)jarg2;
75675   {
75676     try {
75677       (arg1)->ScrollTo(arg2);
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_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75696   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75697   unsigned int arg2 ;
75698   float arg3 ;
75699
75700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75701   arg2 = (unsigned int)jarg2;
75702   arg3 = (float)jarg3;
75703   {
75704     try {
75705       (arg1)->ScrollTo(arg2,arg3);
75706     } catch (std::out_of_range& e) {
75707       {
75708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75709       };
75710     } catch (std::exception& e) {
75711       {
75712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75713       };
75714     } catch (...) {
75715       {
75716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75717       };
75718     }
75719   }
75720 }
75721
75722
75723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75724   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75725   unsigned int arg2 ;
75726   float arg3 ;
75727   Dali::Toolkit::DirectionBias arg4 ;
75728
75729   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75730   arg2 = (unsigned int)jarg2;
75731   arg3 = (float)jarg3;
75732   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75733   {
75734     try {
75735       (arg1)->ScrollTo(arg2,arg3,arg4);
75736     } catch (std::out_of_range& e) {
75737       {
75738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75739       };
75740     } catch (std::exception& e) {
75741       {
75742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75743       };
75744     } catch (...) {
75745       {
75746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75747       };
75748     }
75749   }
75750 }
75751
75752
75753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75754   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75755   Dali::Actor *arg2 = 0 ;
75756
75757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75758   arg2 = (Dali::Actor *)jarg2;
75759   if (!arg2) {
75760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75761     return ;
75762   }
75763   {
75764     try {
75765       (arg1)->ScrollTo(*arg2);
75766     } catch (std::out_of_range& e) {
75767       {
75768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75769       };
75770     } catch (std::exception& e) {
75771       {
75772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75773       };
75774     } catch (...) {
75775       {
75776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75777       };
75778     }
75779   }
75780 }
75781
75782
75783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75784   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75785   Dali::Actor *arg2 = 0 ;
75786   float arg3 ;
75787
75788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75789   arg2 = (Dali::Actor *)jarg2;
75790   if (!arg2) {
75791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75792     return ;
75793   }
75794   arg3 = (float)jarg3;
75795   {
75796     try {
75797       (arg1)->ScrollTo(*arg2,arg3);
75798     } catch (std::out_of_range& e) {
75799       {
75800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75801       };
75802     } catch (std::exception& e) {
75803       {
75804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75805       };
75806     } catch (...) {
75807       {
75808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75809       };
75810     }
75811   }
75812 }
75813
75814
75815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75816   unsigned int jresult ;
75817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75818   bool result;
75819
75820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75821   {
75822     try {
75823       result = (bool)(arg1)->ScrollToSnapPoint();
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75831       };
75832     } catch (...) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75835       };
75836     }
75837   }
75838   jresult = result;
75839   return jresult;
75840 }
75841
75842
75843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75844   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75845   Dali::Constraint arg2 ;
75846   Dali::Constraint *argp2 ;
75847
75848   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75849   argp2 = (Dali::Constraint *)jarg2;
75850   if (!argp2) {
75851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75852     return ;
75853   }
75854   arg2 = *argp2;
75855   {
75856     try {
75857       (arg1)->ApplyConstraintToChildren(arg2);
75858     } catch (std::out_of_range& e) {
75859       {
75860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75861       };
75862     } catch (std::exception& e) {
75863       {
75864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75865       };
75866     } catch (...) {
75867       {
75868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75869       };
75870     }
75871   }
75872 }
75873
75874
75875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75876   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75877
75878   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75879   {
75880     try {
75881       (arg1)->RemoveConstraintsFromChildren();
75882     } catch (std::out_of_range& e) {
75883       {
75884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75885       };
75886     } catch (std::exception& e) {
75887       {
75888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75889       };
75890     } catch (...) {
75891       {
75892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75893       };
75894     }
75895   }
75896 }
75897
75898
75899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75900   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75901   Dali::Toolkit::ScrollViewEffect arg2 ;
75902   Dali::Toolkit::ScrollViewEffect *argp2 ;
75903
75904   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75905   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75906   if (!argp2) {
75907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75908     return ;
75909   }
75910   arg2 = *argp2;
75911   {
75912     try {
75913       (arg1)->ApplyEffect(arg2);
75914     } catch (std::out_of_range& e) {
75915       {
75916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75917       };
75918     } catch (std::exception& e) {
75919       {
75920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75921       };
75922     } catch (...) {
75923       {
75924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75925       };
75926     }
75927   }
75928 }
75929
75930
75931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75933   Dali::Toolkit::ScrollViewEffect arg2 ;
75934   Dali::Toolkit::ScrollViewEffect *argp2 ;
75935
75936   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75937   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75938   if (!argp2) {
75939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75940     return ;
75941   }
75942   arg2 = *argp2;
75943   {
75944     try {
75945       (arg1)->RemoveEffect(arg2);
75946     } catch (std::out_of_range& e) {
75947       {
75948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75949       };
75950     } catch (std::exception& e) {
75951       {
75952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75953       };
75954     } catch (...) {
75955       {
75956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75957       };
75958     }
75959   }
75960 }
75961
75962
75963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75965
75966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75967   {
75968     try {
75969       (arg1)->RemoveAllEffects();
75970     } catch (std::out_of_range& e) {
75971       {
75972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75973       };
75974     } catch (std::exception& e) {
75975       {
75976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75977       };
75978     } catch (...) {
75979       {
75980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75981       };
75982     }
75983   }
75984 }
75985
75986
75987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75989   Dali::Actor arg2 ;
75990   Dali::Actor *argp2 ;
75991
75992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75993   argp2 = (Dali::Actor *)jarg2;
75994   if (!argp2) {
75995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75996     return ;
75997   }
75998   arg2 = *argp2;
75999   {
76000     try {
76001       (arg1)->BindActor(arg2);
76002     } catch (std::out_of_range& e) {
76003       {
76004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76005       };
76006     } catch (std::exception& e) {
76007       {
76008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76009       };
76010     } catch (...) {
76011       {
76012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76013       };
76014     }
76015   }
76016 }
76017
76018
76019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76021   Dali::Actor arg2 ;
76022   Dali::Actor *argp2 ;
76023
76024   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76025   argp2 = (Dali::Actor *)jarg2;
76026   if (!argp2) {
76027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76028     return ;
76029   }
76030   arg2 = *argp2;
76031   {
76032     try {
76033       (arg1)->UnbindActor(arg2);
76034     } catch (std::out_of_range& e) {
76035       {
76036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76037       };
76038     } catch (std::exception& e) {
76039       {
76040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76041       };
76042     } catch (...) {
76043       {
76044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76045       };
76046     }
76047   }
76048 }
76049
76050
76051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76053   Dali::Radian arg2 ;
76054   Dali::Radian arg3 ;
76055   Dali::Radian *argp2 ;
76056   Dali::Radian *argp3 ;
76057
76058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76059   argp2 = (Dali::Radian *)jarg2;
76060   if (!argp2) {
76061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76062     return ;
76063   }
76064   arg2 = *argp2;
76065   argp3 = (Dali::Radian *)jarg3;
76066   if (!argp3) {
76067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76068     return ;
76069   }
76070   arg3 = *argp3;
76071   {
76072     try {
76073       (arg1)->SetScrollingDirection(arg2,arg3);
76074     } catch (std::out_of_range& e) {
76075       {
76076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76077       };
76078     } catch (std::exception& e) {
76079       {
76080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76081       };
76082     } catch (...) {
76083       {
76084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76085       };
76086     }
76087   }
76088 }
76089
76090
76091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76092   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76093   Dali::Radian arg2 ;
76094   Dali::Radian *argp2 ;
76095
76096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76097   argp2 = (Dali::Radian *)jarg2;
76098   if (!argp2) {
76099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76100     return ;
76101   }
76102   arg2 = *argp2;
76103   {
76104     try {
76105       (arg1)->SetScrollingDirection(arg2);
76106     } catch (std::out_of_range& e) {
76107       {
76108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76109       };
76110     } catch (std::exception& e) {
76111       {
76112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76113       };
76114     } catch (...) {
76115       {
76116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76117       };
76118     }
76119   }
76120 }
76121
76122
76123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76125   Dali::Radian arg2 ;
76126   Dali::Radian *argp2 ;
76127
76128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76129   argp2 = (Dali::Radian *)jarg2;
76130   if (!argp2) {
76131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76132     return ;
76133   }
76134   arg2 = *argp2;
76135   {
76136     try {
76137       (arg1)->RemoveScrollingDirection(arg2);
76138     } catch (std::out_of_range& e) {
76139       {
76140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76141       };
76142     } catch (std::exception& e) {
76143       {
76144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76145       };
76146     } catch (...) {
76147       {
76148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76149       };
76150     }
76151   }
76152 }
76153
76154
76155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76156   void * jresult ;
76157   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76158   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76159
76160   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76161   {
76162     try {
76163       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
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 int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76184   int jresult ;
76185   int result;
76186
76187   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76188   jresult = (int)result;
76189   return jresult;
76190 }
76191
76192
76193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76194   int jresult ;
76195   int result;
76196
76197   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76198   jresult = (int)result;
76199   return jresult;
76200 }
76201
76202
76203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76204   int jresult ;
76205   int result;
76206
76207   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76208   jresult = (int)result;
76209   return jresult;
76210 }
76211
76212
76213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76214   int jresult ;
76215   int result;
76216
76217   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76218   jresult = (int)result;
76219   return jresult;
76220 }
76221
76222
76223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76224   int jresult ;
76225   int result;
76226
76227   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76228   jresult = (int)result;
76229   return jresult;
76230 }
76231
76232
76233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76234   void * jresult ;
76235   Dali::Toolkit::TableView::Property *result = 0 ;
76236
76237   {
76238     try {
76239       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
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 = (void *)result;
76255   return jresult;
76256 }
76257
76258
76259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76260   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76261
76262   arg1 = (Dali::Toolkit::TableView::Property *)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 int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76284   int jresult ;
76285   int result;
76286
76287   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76288   jresult = (int)result;
76289   return jresult;
76290 }
76291
76292
76293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76294   int jresult ;
76295   int result;
76296
76297   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76298   jresult = (int)result;
76299   return jresult;
76300 }
76301
76302
76303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76304   int jresult ;
76305   int result;
76306
76307   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76308   jresult = (int)result;
76309   return jresult;
76310 }
76311
76312
76313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76314   int jresult ;
76315   int result;
76316
76317   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76318   jresult = (int)result;
76319   return jresult;
76320 }
76321
76322
76323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76324   int jresult ;
76325   int result;
76326
76327   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76328   jresult = (int)result;
76329   return jresult;
76330 }
76331
76332
76333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76334   void * jresult ;
76335   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76336
76337   {
76338     try {
76339       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76340     } catch (std::out_of_range& e) {
76341       {
76342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76343       };
76344     } catch (std::exception& e) {
76345       {
76346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76347       };
76348     } catch (...) {
76349       {
76350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76351       };
76352     }
76353   }
76354   jresult = (void *)result;
76355   return jresult;
76356 }
76357
76358
76359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76360   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76361
76362   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76363   {
76364     try {
76365       delete arg1;
76366     } catch (std::out_of_range& e) {
76367       {
76368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76369       };
76370     } catch (std::exception& e) {
76371       {
76372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76373       };
76374     } catch (...) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76377       };
76378     }
76379   }
76380 }
76381
76382
76383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76384   void * jresult ;
76385   unsigned int arg1 ;
76386   unsigned int arg2 ;
76387   unsigned int arg3 ;
76388   unsigned int arg4 ;
76389   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76390
76391   arg1 = (unsigned int)jarg1;
76392   arg2 = (unsigned int)jarg2;
76393   arg3 = (unsigned int)jarg3;
76394   arg4 = (unsigned int)jarg4;
76395   {
76396     try {
76397       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76398     } catch (std::out_of_range& e) {
76399       {
76400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76401       };
76402     } catch (std::exception& e) {
76403       {
76404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76405       };
76406     } catch (...) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76409       };
76410     }
76411   }
76412   jresult = (void *)result;
76413   return jresult;
76414 }
76415
76416
76417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76418   void * jresult ;
76419   unsigned int arg1 ;
76420   unsigned int arg2 ;
76421   unsigned int arg3 ;
76422   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76423
76424   arg1 = (unsigned int)jarg1;
76425   arg2 = (unsigned int)jarg2;
76426   arg3 = (unsigned int)jarg3;
76427   {
76428     try {
76429       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76430     } catch (std::out_of_range& e) {
76431       {
76432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76433       };
76434     } catch (std::exception& e) {
76435       {
76436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76437       };
76438     } catch (...) {
76439       {
76440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76441       };
76442     }
76443   }
76444   jresult = (void *)result;
76445   return jresult;
76446 }
76447
76448
76449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76450   void * jresult ;
76451   unsigned int arg1 ;
76452   unsigned int arg2 ;
76453   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76454
76455   arg1 = (unsigned int)jarg1;
76456   arg2 = (unsigned int)jarg2;
76457   {
76458     try {
76459       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76460     } catch (std::out_of_range& e) {
76461       {
76462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76463       };
76464     } catch (std::exception& e) {
76465       {
76466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76467       };
76468     } catch (...) {
76469       {
76470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76471       };
76472     }
76473   }
76474   jresult = (void *)result;
76475   return jresult;
76476 }
76477
76478
76479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76480   void * jresult ;
76481   unsigned int arg1 ;
76482   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76483
76484   arg1 = (unsigned int)jarg1;
76485   {
76486     try {
76487       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76488     } catch (std::out_of_range& e) {
76489       {
76490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76491       };
76492     } catch (std::exception& e) {
76493       {
76494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76495       };
76496     } catch (...) {
76497       {
76498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76499       };
76500     }
76501   }
76502   jresult = (void *)result;
76503   return jresult;
76504 }
76505
76506
76507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76508   void * jresult ;
76509   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76510
76511   {
76512     try {
76513       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76514     } catch (std::out_of_range& e) {
76515       {
76516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76517       };
76518     } catch (std::exception& e) {
76519       {
76520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76521       };
76522     } catch (...) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76525       };
76526     }
76527   }
76528   jresult = (void *)result;
76529   return jresult;
76530 }
76531
76532
76533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76534   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76535   unsigned int arg2 ;
76536
76537   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76538   arg2 = (unsigned int)jarg2;
76539   if (arg1) (arg1)->rowIndex = arg2;
76540 }
76541
76542
76543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76544   unsigned int jresult ;
76545   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76546   unsigned int result;
76547
76548   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76549   result = (unsigned int) ((arg1)->rowIndex);
76550   jresult = result;
76551   return jresult;
76552 }
76553
76554
76555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76556   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76557   unsigned int arg2 ;
76558
76559   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76560   arg2 = (unsigned int)jarg2;
76561   if (arg1) (arg1)->columnIndex = arg2;
76562 }
76563
76564
76565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76566   unsigned int jresult ;
76567   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76568   unsigned int result;
76569
76570   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76571   result = (unsigned int) ((arg1)->columnIndex);
76572   jresult = result;
76573   return jresult;
76574 }
76575
76576
76577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76578   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76579   unsigned int arg2 ;
76580
76581   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76582   arg2 = (unsigned int)jarg2;
76583   if (arg1) (arg1)->rowSpan = arg2;
76584 }
76585
76586
76587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76588   unsigned int jresult ;
76589   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76590   unsigned int result;
76591
76592   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76593   result = (unsigned int) ((arg1)->rowSpan);
76594   jresult = result;
76595   return jresult;
76596 }
76597
76598
76599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76600   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76601   unsigned int arg2 ;
76602
76603   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76604   arg2 = (unsigned int)jarg2;
76605   if (arg1) (arg1)->columnSpan = arg2;
76606 }
76607
76608
76609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76610   unsigned int jresult ;
76611   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76612   unsigned int result;
76613
76614   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76615   result = (unsigned int) ((arg1)->columnSpan);
76616   jresult = result;
76617   return jresult;
76618 }
76619
76620
76621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76622   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76623
76624   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76625   {
76626     try {
76627       delete arg1;
76628     } catch (std::out_of_range& e) {
76629       {
76630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76631       };
76632     } catch (std::exception& e) {
76633       {
76634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76635       };
76636     } catch (...) {
76637       {
76638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76639       };
76640     }
76641   }
76642 }
76643
76644
76645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76646   void * jresult ;
76647   Dali::Toolkit::TableView *result = 0 ;
76648
76649   {
76650     try {
76651       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76652     } catch (std::out_of_range& e) {
76653       {
76654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76655       };
76656     } catch (std::exception& e) {
76657       {
76658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76663       };
76664     }
76665   }
76666   jresult = (void *)result;
76667   return jresult;
76668 }
76669
76670
76671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76672   void * jresult ;
76673   Dali::Toolkit::TableView *arg1 = 0 ;
76674   Dali::Toolkit::TableView *result = 0 ;
76675
76676   arg1 = (Dali::Toolkit::TableView *)jarg1;
76677   if (!arg1) {
76678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76679     return 0;
76680   }
76681   {
76682     try {
76683       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76684     } catch (std::out_of_range& e) {
76685       {
76686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76687       };
76688     } catch (std::exception& e) {
76689       {
76690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76691       };
76692     } catch (...) {
76693       {
76694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76695       };
76696     }
76697   }
76698   jresult = (void *)result;
76699   return jresult;
76700 }
76701
76702
76703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76704   void * jresult ;
76705   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76706   Dali::Toolkit::TableView *arg2 = 0 ;
76707   Dali::Toolkit::TableView *result = 0 ;
76708
76709   arg1 = (Dali::Toolkit::TableView *)jarg1;
76710   arg2 = (Dali::Toolkit::TableView *)jarg2;
76711   if (!arg2) {
76712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76713     return 0;
76714   }
76715   {
76716     try {
76717       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76725       };
76726     } catch (...) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76729       };
76730     }
76731   }
76732   jresult = (void *)result;
76733   return jresult;
76734 }
76735
76736
76737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76739
76740   arg1 = (Dali::Toolkit::TableView *)jarg1;
76741   {
76742     try {
76743       delete arg1;
76744     } catch (std::out_of_range& e) {
76745       {
76746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76747       };
76748     } catch (std::exception& e) {
76749       {
76750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76751       };
76752     } catch (...) {
76753       {
76754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76755       };
76756     }
76757   }
76758 }
76759
76760
76761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76762   void * jresult ;
76763   unsigned int arg1 ;
76764   unsigned int arg2 ;
76765   Dali::Toolkit::TableView result;
76766
76767   arg1 = (unsigned int)jarg1;
76768   arg2 = (unsigned int)jarg2;
76769   {
76770     try {
76771       result = Dali::Toolkit::TableView::New(arg1,arg2);
76772     } catch (std::out_of_range& e) {
76773       {
76774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76775       };
76776     } catch (std::exception& e) {
76777       {
76778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76779       };
76780     } catch (...) {
76781       {
76782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76783       };
76784     }
76785   }
76786   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76787   return jresult;
76788 }
76789
76790
76791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76792   void * jresult ;
76793   Dali::BaseHandle arg1 ;
76794   Dali::BaseHandle *argp1 ;
76795   Dali::Toolkit::TableView result;
76796
76797   argp1 = (Dali::BaseHandle *)jarg1;
76798   if (!argp1) {
76799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76800     return 0;
76801   }
76802   arg1 = *argp1;
76803   {
76804     try {
76805       result = Dali::Toolkit::TableView::DownCast(arg1);
76806     } catch (std::out_of_range& e) {
76807       {
76808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76809       };
76810     } catch (std::exception& e) {
76811       {
76812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76813       };
76814     } catch (...) {
76815       {
76816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76817       };
76818     }
76819   }
76820   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76821   return jresult;
76822 }
76823
76824
76825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76826   unsigned int jresult ;
76827   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76828   Dali::Actor arg2 ;
76829   Dali::Toolkit::TableView::CellPosition arg3 ;
76830   Dali::Actor *argp2 ;
76831   Dali::Toolkit::TableView::CellPosition *argp3 ;
76832   bool result;
76833
76834   arg1 = (Dali::Toolkit::TableView *)jarg1;
76835   argp2 = (Dali::Actor *)jarg2;
76836   if (!argp2) {
76837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76838     return 0;
76839   }
76840   arg2 = *argp2;
76841   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76842   if (!argp3) {
76843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76844     return 0;
76845   }
76846   arg3 = *argp3;
76847   {
76848     try {
76849       result = (bool)(arg1)->AddChild(arg2,arg3);
76850     } catch (std::out_of_range& e) {
76851       {
76852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76853       };
76854     } catch (std::exception& e) {
76855       {
76856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76857       };
76858     } catch (...) {
76859       {
76860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76861       };
76862     }
76863   }
76864   jresult = result;
76865   return jresult;
76866 }
76867
76868
76869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76870   void * jresult ;
76871   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76872   Dali::Toolkit::TableView::CellPosition arg2 ;
76873   Dali::Toolkit::TableView::CellPosition *argp2 ;
76874   Dali::Actor result;
76875
76876   arg1 = (Dali::Toolkit::TableView *)jarg1;
76877   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76878   if (!argp2) {
76879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76880     return 0;
76881   }
76882   arg2 = *argp2;
76883   {
76884     try {
76885       result = (arg1)->GetChildAt(arg2);
76886     } catch (std::out_of_range& e) {
76887       {
76888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76889       };
76890     } catch (std::exception& e) {
76891       {
76892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76893       };
76894     } catch (...) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76897       };
76898     }
76899   }
76900   jresult = new Dali::Actor((const Dali::Actor &)result);
76901   return jresult;
76902 }
76903
76904
76905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76906   void * jresult ;
76907   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76908   Dali::Toolkit::TableView::CellPosition arg2 ;
76909   Dali::Toolkit::TableView::CellPosition *argp2 ;
76910   Dali::Actor result;
76911
76912   arg1 = (Dali::Toolkit::TableView *)jarg1;
76913   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76914   if (!argp2) {
76915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76916     return 0;
76917   }
76918   arg2 = *argp2;
76919   {
76920     try {
76921       result = (arg1)->RemoveChildAt(arg2);
76922     } catch (std::out_of_range& e) {
76923       {
76924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76925       };
76926     } catch (std::exception& e) {
76927       {
76928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76929       };
76930     } catch (...) {
76931       {
76932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76933       };
76934     }
76935   }
76936   jresult = new Dali::Actor((const Dali::Actor &)result);
76937   return jresult;
76938 }
76939
76940
76941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76942   unsigned int jresult ;
76943   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76944   Dali::Actor arg2 ;
76945   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76946   Dali::Actor *argp2 ;
76947   bool result;
76948
76949   arg1 = (Dali::Toolkit::TableView *)jarg1;
76950   argp2 = (Dali::Actor *)jarg2;
76951   if (!argp2) {
76952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76953     return 0;
76954   }
76955   arg2 = *argp2;
76956   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76957   if (!arg3) {
76958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76959     return 0;
76960   }
76961   {
76962     try {
76963       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76964     } catch (std::out_of_range& e) {
76965       {
76966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76967       };
76968     } catch (std::exception& e) {
76969       {
76970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76971       };
76972     } catch (...) {
76973       {
76974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76975       };
76976     }
76977   }
76978   jresult = result;
76979   return jresult;
76980 }
76981
76982
76983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76984   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76985   unsigned int arg2 ;
76986
76987   arg1 = (Dali::Toolkit::TableView *)jarg1;
76988   arg2 = (unsigned int)jarg2;
76989   {
76990     try {
76991       (arg1)->InsertRow(arg2);
76992     } catch (std::out_of_range& e) {
76993       {
76994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76995       };
76996     } catch (std::exception& e) {
76997       {
76998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76999       };
77000     } catch (...) {
77001       {
77002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77003       };
77004     }
77005   }
77006 }
77007
77008
77009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77010   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77011   unsigned int arg2 ;
77012
77013   arg1 = (Dali::Toolkit::TableView *)jarg1;
77014   arg2 = (unsigned int)jarg2;
77015   {
77016     try {
77017       (arg1)->DeleteRow(arg2);
77018     } catch (std::out_of_range& e) {
77019       {
77020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77021       };
77022     } catch (std::exception& e) {
77023       {
77024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77025       };
77026     } catch (...) {
77027       {
77028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77029       };
77030     }
77031   }
77032 }
77033
77034
77035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77036   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77037   unsigned int arg2 ;
77038   std::vector< Dali::Actor > *arg3 = 0 ;
77039
77040   arg1 = (Dali::Toolkit::TableView *)jarg1;
77041   arg2 = (unsigned int)jarg2;
77042   arg3 = (std::vector< Dali::Actor > *)jarg3;
77043   if (!arg3) {
77044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77045     return ;
77046   }
77047   {
77048     try {
77049       (arg1)->DeleteRow(arg2,*arg3);
77050     } catch (std::out_of_range& e) {
77051       {
77052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77053       };
77054     } catch (std::exception& e) {
77055       {
77056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77057       };
77058     } catch (...) {
77059       {
77060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77061       };
77062     }
77063   }
77064 }
77065
77066
77067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77068   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77069   unsigned int arg2 ;
77070
77071   arg1 = (Dali::Toolkit::TableView *)jarg1;
77072   arg2 = (unsigned int)jarg2;
77073   {
77074     try {
77075       (arg1)->InsertColumn(arg2);
77076     } catch (std::out_of_range& e) {
77077       {
77078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77079       };
77080     } catch (std::exception& e) {
77081       {
77082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77083       };
77084     } catch (...) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77087       };
77088     }
77089   }
77090 }
77091
77092
77093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77094   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77095   unsigned int arg2 ;
77096
77097   arg1 = (Dali::Toolkit::TableView *)jarg1;
77098   arg2 = (unsigned int)jarg2;
77099   {
77100     try {
77101       (arg1)->DeleteColumn(arg2);
77102     } catch (std::out_of_range& e) {
77103       {
77104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77105       };
77106     } catch (std::exception& e) {
77107       {
77108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77109       };
77110     } catch (...) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77113       };
77114     }
77115   }
77116 }
77117
77118
77119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77120   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77121   unsigned int arg2 ;
77122   std::vector< Dali::Actor > *arg3 = 0 ;
77123
77124   arg1 = (Dali::Toolkit::TableView *)jarg1;
77125   arg2 = (unsigned int)jarg2;
77126   arg3 = (std::vector< Dali::Actor > *)jarg3;
77127   if (!arg3) {
77128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77129     return ;
77130   }
77131   {
77132     try {
77133       (arg1)->DeleteColumn(arg2,*arg3);
77134     } catch (std::out_of_range& e) {
77135       {
77136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77137       };
77138     } catch (std::exception& e) {
77139       {
77140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77141       };
77142     } catch (...) {
77143       {
77144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77145       };
77146     }
77147   }
77148 }
77149
77150
77151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77152   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77153   unsigned int arg2 ;
77154   unsigned int arg3 ;
77155
77156   arg1 = (Dali::Toolkit::TableView *)jarg1;
77157   arg2 = (unsigned int)jarg2;
77158   arg3 = (unsigned int)jarg3;
77159   {
77160     try {
77161       (arg1)->Resize(arg2,arg3);
77162     } catch (std::out_of_range& e) {
77163       {
77164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77165       };
77166     } catch (std::exception& e) {
77167       {
77168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77169       };
77170     } catch (...) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77173       };
77174     }
77175   }
77176 }
77177
77178
77179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77180   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77181   unsigned int arg2 ;
77182   unsigned int arg3 ;
77183   std::vector< Dali::Actor > *arg4 = 0 ;
77184
77185   arg1 = (Dali::Toolkit::TableView *)jarg1;
77186   arg2 = (unsigned int)jarg2;
77187   arg3 = (unsigned int)jarg3;
77188   arg4 = (std::vector< Dali::Actor > *)jarg4;
77189   if (!arg4) {
77190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77191     return ;
77192   }
77193   {
77194     try {
77195       (arg1)->Resize(arg2,arg3,*arg4);
77196     } catch (std::out_of_range& e) {
77197       {
77198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77199       };
77200     } catch (std::exception& e) {
77201       {
77202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77203       };
77204     } catch (...) {
77205       {
77206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77207       };
77208     }
77209   }
77210 }
77211
77212
77213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77214   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77215   Dali::Size arg2 ;
77216   Dali::Size *argp2 ;
77217
77218   arg1 = (Dali::Toolkit::TableView *)jarg1;
77219   argp2 = (Dali::Size *)jarg2;
77220   if (!argp2) {
77221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77222     return ;
77223   }
77224   arg2 = *argp2;
77225   {
77226     try {
77227       (arg1)->SetCellPadding(arg2);
77228     } catch (std::out_of_range& e) {
77229       {
77230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77231       };
77232     } catch (std::exception& e) {
77233       {
77234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77235       };
77236     } catch (...) {
77237       {
77238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77239       };
77240     }
77241   }
77242 }
77243
77244
77245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77246   void * jresult ;
77247   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77248   Dali::Size result;
77249
77250   arg1 = (Dali::Toolkit::TableView *)jarg1;
77251   {
77252     try {
77253       result = (arg1)->GetCellPadding();
77254     } catch (std::out_of_range& e) {
77255       {
77256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77257       };
77258     } catch (std::exception& e) {
77259       {
77260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77261       };
77262     } catch (...) {
77263       {
77264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77265       };
77266     }
77267   }
77268   jresult = new Dali::Size((const Dali::Size &)result);
77269   return jresult;
77270 }
77271
77272
77273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77274   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77275   unsigned int arg2 ;
77276
77277   arg1 = (Dali::Toolkit::TableView *)jarg1;
77278   arg2 = (unsigned int)jarg2;
77279   {
77280     try {
77281       (arg1)->SetFitHeight(arg2);
77282     } catch (std::out_of_range& e) {
77283       {
77284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77285       };
77286     } catch (std::exception& e) {
77287       {
77288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77289       };
77290     } catch (...) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77293       };
77294     }
77295   }
77296 }
77297
77298
77299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77300   unsigned int jresult ;
77301   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77302   unsigned int arg2 ;
77303   bool result;
77304
77305   arg1 = (Dali::Toolkit::TableView *)jarg1;
77306   arg2 = (unsigned int)jarg2;
77307   {
77308     try {
77309       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77310     } catch (std::out_of_range& e) {
77311       {
77312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77313       };
77314     } catch (std::exception& e) {
77315       {
77316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77317       };
77318     } catch (...) {
77319       {
77320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77321       };
77322     }
77323   }
77324   jresult = result;
77325   return jresult;
77326 }
77327
77328
77329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77330   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77331   unsigned int arg2 ;
77332
77333   arg1 = (Dali::Toolkit::TableView *)jarg1;
77334   arg2 = (unsigned int)jarg2;
77335   {
77336     try {
77337       (arg1)->SetFitWidth(arg2);
77338     } catch (std::out_of_range& e) {
77339       {
77340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77341       };
77342     } catch (std::exception& e) {
77343       {
77344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77345       };
77346     } catch (...) {
77347       {
77348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77349       };
77350     }
77351   }
77352 }
77353
77354
77355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77356   unsigned int jresult ;
77357   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77358   unsigned int arg2 ;
77359   bool result;
77360
77361   arg1 = (Dali::Toolkit::TableView *)jarg1;
77362   arg2 = (unsigned int)jarg2;
77363   {
77364     try {
77365       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77373       };
77374     } catch (...) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77377       };
77378     }
77379   }
77380   jresult = result;
77381   return jresult;
77382 }
77383
77384
77385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77386   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77387   unsigned int arg2 ;
77388   float arg3 ;
77389
77390   arg1 = (Dali::Toolkit::TableView *)jarg1;
77391   arg2 = (unsigned int)jarg2;
77392   arg3 = (float)jarg3;
77393   {
77394     try {
77395       (arg1)->SetFixedHeight(arg2,arg3);
77396     } catch (std::out_of_range& e) {
77397       {
77398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77399       };
77400     } catch (std::exception& e) {
77401       {
77402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77403       };
77404     } catch (...) {
77405       {
77406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77407       };
77408     }
77409   }
77410 }
77411
77412
77413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77414   float jresult ;
77415   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77416   unsigned int arg2 ;
77417   float result;
77418
77419   arg1 = (Dali::Toolkit::TableView *)jarg1;
77420   arg2 = (unsigned int)jarg2;
77421   {
77422     try {
77423       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77424     } catch (std::out_of_range& e) {
77425       {
77426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77427       };
77428     } catch (std::exception& e) {
77429       {
77430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77431       };
77432     } catch (...) {
77433       {
77434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77435       };
77436     }
77437   }
77438   jresult = result;
77439   return jresult;
77440 }
77441
77442
77443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77444   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77445   unsigned int arg2 ;
77446   float arg3 ;
77447
77448   arg1 = (Dali::Toolkit::TableView *)jarg1;
77449   arg2 = (unsigned int)jarg2;
77450   arg3 = (float)jarg3;
77451   {
77452     try {
77453       (arg1)->SetRelativeHeight(arg2,arg3);
77454     } catch (std::out_of_range& e) {
77455       {
77456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77457       };
77458     } catch (std::exception& e) {
77459       {
77460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77461       };
77462     } catch (...) {
77463       {
77464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77465       };
77466     }
77467   }
77468 }
77469
77470
77471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77472   float jresult ;
77473   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77474   unsigned int arg2 ;
77475   float result;
77476
77477   arg1 = (Dali::Toolkit::TableView *)jarg1;
77478   arg2 = (unsigned int)jarg2;
77479   {
77480     try {
77481       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77482     } catch (std::out_of_range& e) {
77483       {
77484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77485       };
77486     } catch (std::exception& e) {
77487       {
77488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77489       };
77490     } catch (...) {
77491       {
77492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77493       };
77494     }
77495   }
77496   jresult = result;
77497   return jresult;
77498 }
77499
77500
77501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77503   unsigned int arg2 ;
77504   float arg3 ;
77505
77506   arg1 = (Dali::Toolkit::TableView *)jarg1;
77507   arg2 = (unsigned int)jarg2;
77508   arg3 = (float)jarg3;
77509   {
77510     try {
77511       (arg1)->SetFixedWidth(arg2,arg3);
77512     } catch (std::out_of_range& e) {
77513       {
77514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77515       };
77516     } catch (std::exception& e) {
77517       {
77518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77519       };
77520     } catch (...) {
77521       {
77522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77523       };
77524     }
77525   }
77526 }
77527
77528
77529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77530   float jresult ;
77531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77532   unsigned int arg2 ;
77533   float result;
77534
77535   arg1 = (Dali::Toolkit::TableView *)jarg1;
77536   arg2 = (unsigned int)jarg2;
77537   {
77538     try {
77539       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77540     } catch (std::out_of_range& e) {
77541       {
77542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77543       };
77544     } catch (std::exception& e) {
77545       {
77546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77547       };
77548     } catch (...) {
77549       {
77550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77551       };
77552     }
77553   }
77554   jresult = result;
77555   return jresult;
77556 }
77557
77558
77559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77560   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77561   unsigned int arg2 ;
77562   float arg3 ;
77563
77564   arg1 = (Dali::Toolkit::TableView *)jarg1;
77565   arg2 = (unsigned int)jarg2;
77566   arg3 = (float)jarg3;
77567   {
77568     try {
77569       (arg1)->SetRelativeWidth(arg2,arg3);
77570     } catch (std::out_of_range& e) {
77571       {
77572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77573       };
77574     } catch (std::exception& e) {
77575       {
77576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77577       };
77578     } catch (...) {
77579       {
77580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77581       };
77582     }
77583   }
77584 }
77585
77586
77587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77588   float jresult ;
77589   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77590   unsigned int arg2 ;
77591   float result;
77592
77593   arg1 = (Dali::Toolkit::TableView *)jarg1;
77594   arg2 = (unsigned int)jarg2;
77595   {
77596     try {
77597       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77598     } catch (std::out_of_range& e) {
77599       {
77600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77601       };
77602     } catch (std::exception& e) {
77603       {
77604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77605       };
77606     } catch (...) {
77607       {
77608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77609       };
77610     }
77611   }
77612   jresult = result;
77613   return jresult;
77614 }
77615
77616
77617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77618   unsigned int jresult ;
77619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77620   unsigned int result;
77621
77622   arg1 = (Dali::Toolkit::TableView *)jarg1;
77623   {
77624     try {
77625       result = (unsigned int)(arg1)->GetRows();
77626     } catch (std::out_of_range& e) {
77627       {
77628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77629       };
77630     } catch (std::exception& e) {
77631       {
77632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77633       };
77634     } catch (...) {
77635       {
77636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77637       };
77638     }
77639   }
77640   jresult = result;
77641   return jresult;
77642 }
77643
77644
77645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77646   unsigned int jresult ;
77647   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77648   unsigned int result;
77649
77650   arg1 = (Dali::Toolkit::TableView *)jarg1;
77651   {
77652     try {
77653       result = (unsigned int)(arg1)->GetColumns();
77654     } catch (std::out_of_range& e) {
77655       {
77656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77657       };
77658     } catch (std::exception& e) {
77659       {
77660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77661       };
77662     } catch (...) {
77663       {
77664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77665       };
77666     }
77667   }
77668   jresult = result;
77669   return jresult;
77670 }
77671
77672
77673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77674   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77675   Dali::Toolkit::TableView::CellPosition arg2 ;
77676   Dali::HorizontalAlignment::Type arg3 ;
77677   Dali::VerticalAlignment::Type arg4 ;
77678   Dali::Toolkit::TableView::CellPosition *argp2 ;
77679
77680   arg1 = (Dali::Toolkit::TableView *)jarg1;
77681   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77682   if (!argp2) {
77683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77684     return ;
77685   }
77686   arg2 = *argp2;
77687   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77688   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77689   {
77690     try {
77691       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77692     } catch (std::out_of_range& e) {
77693       {
77694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77695       };
77696     } catch (std::exception& e) {
77697       {
77698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77699       };
77700     } catch (...) {
77701       {
77702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77703       };
77704     }
77705   }
77706 }
77707
77708
77709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77710   unsigned int jresult ;
77711   unsigned int result;
77712
77713   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77714   jresult = result;
77715   return jresult;
77716 }
77717
77718
77719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77720   int jresult ;
77721   int result;
77722
77723   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77724   jresult = (int)result;
77725   return jresult;
77726 }
77727
77728
77729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77730   int jresult ;
77731   int result;
77732
77733   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77734   jresult = (int)result;
77735   return jresult;
77736 }
77737
77738
77739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77740   int jresult ;
77741   int result;
77742
77743   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77744   jresult = (int)result;
77745   return jresult;
77746 }
77747
77748
77749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77750   int jresult ;
77751   int result;
77752
77753   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77754   jresult = (int)result;
77755   return jresult;
77756 }
77757
77758
77759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77760   int jresult ;
77761   int result;
77762
77763   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77764   jresult = (int)result;
77765   return jresult;
77766 }
77767
77768
77769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77770   int jresult ;
77771   int result;
77772
77773   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77774   jresult = (int)result;
77775   return jresult;
77776 }
77777
77778
77779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77780   int jresult ;
77781   int result;
77782
77783   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77784   jresult = (int)result;
77785   return jresult;
77786 }
77787
77788
77789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77790   int jresult ;
77791   int result;
77792
77793   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77794   jresult = (int)result;
77795   return jresult;
77796 }
77797
77798
77799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77800   int jresult ;
77801   int result;
77802
77803   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77804   jresult = (int)result;
77805   return jresult;
77806 }
77807
77808
77809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77810   int jresult ;
77811   int result;
77812
77813   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77814   jresult = (int)result;
77815   return jresult;
77816 }
77817
77818
77819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77820   int jresult ;
77821   int result;
77822
77823   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77824   jresult = (int)result;
77825   return jresult;
77826 }
77827
77828
77829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77830   int jresult ;
77831   int result;
77832
77833   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77834   jresult = (int)result;
77835   return jresult;
77836 }
77837
77838
77839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77840   int jresult ;
77841   int result;
77842
77843   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77844   jresult = (int)result;
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77850   int jresult ;
77851   int result;
77852
77853   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77854   jresult = (int)result;
77855   return jresult;
77856 }
77857
77858
77859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77860   int jresult ;
77861   int result;
77862
77863   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77864   jresult = (int)result;
77865   return jresult;
77866 }
77867
77868
77869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77870   int jresult ;
77871   int result;
77872
77873   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77874   jresult = (int)result;
77875   return jresult;
77876 }
77877
77878
77879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77880   int jresult ;
77881   int result;
77882
77883   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77884   jresult = (int)result;
77885   return jresult;
77886 }
77887
77888
77889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77890   int jresult ;
77891   int result;
77892
77893   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77894   jresult = (int)result;
77895   return jresult;
77896 }
77897
77898
77899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77900   int jresult ;
77901   int result;
77902
77903   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77904   jresult = (int)result;
77905   return jresult;
77906 }
77907
77908
77909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77910   int jresult ;
77911   int result;
77912
77913   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77914   jresult = (int)result;
77915   return jresult;
77916 }
77917
77918
77919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77920   int jresult ;
77921   int result;
77922
77923   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77924   jresult = (int)result;
77925   return jresult;
77926 }
77927
77928
77929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77930   int jresult ;
77931   int result;
77932
77933   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77934   jresult = (int)result;
77935   return jresult;
77936 }
77937
77938
77939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77940   int jresult ;
77941   int result;
77942
77943   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77944   jresult = (int)result;
77945   return jresult;
77946 }
77947
77948
77949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77950   int jresult ;
77951   int result;
77952
77953   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77954   jresult = (int)result;
77955   return jresult;
77956 }
77957
77958
77959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77960   int jresult ;
77961   int result;
77962
77963   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77964   jresult = (int)result;
77965   return jresult;
77966 }
77967
77968
77969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77970   int jresult ;
77971   int result;
77972
77973   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77974   jresult = (int)result;
77975   return jresult;
77976 }
77977
77978
77979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77980   int jresult ;
77981   int result;
77982
77983   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77984   jresult = (int)result;
77985   return jresult;
77986 }
77987
77988
77989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77990   int jresult ;
77991   int result;
77992
77993   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77994   jresult = (int)result;
77995   return jresult;
77996 }
77997
77998
77999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
78000   int jresult ;
78001   int result;
78002
78003   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
78004   jresult = (int)result;
78005   return jresult;
78006 }
78007
78008
78009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
78010   int jresult ;
78011   int result;
78012
78013   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
78014   jresult = (int)result;
78015   return jresult;
78016 }
78017
78018
78019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
78020   int jresult ;
78021   int result;
78022
78023   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
78024   jresult = (int)result;
78025   return jresult;
78026 }
78027
78028
78029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
78030   int jresult ;
78031   int result;
78032
78033   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
78034   jresult = (int)result;
78035   return jresult;
78036 }
78037
78038
78039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
78040   int jresult ;
78041   int result;
78042
78043   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
78044   jresult = (int)result;
78045   return jresult;
78046 }
78047
78048
78049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
78050   int jresult ;
78051   int result;
78052
78053   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
78054   jresult = (int)result;
78055   return jresult;
78056 }
78057
78058
78059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
78060   int jresult ;
78061   int result;
78062
78063   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
78064   jresult = (int)result;
78065   return jresult;
78066 }
78067
78068
78069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
78070   int jresult ;
78071   int result;
78072
78073   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
78074   jresult = (int)result;
78075   return jresult;
78076 }
78077
78078
78079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78080   int jresult ;
78081   int result;
78082
78083   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78084   jresult = (int)result;
78085   return jresult;
78086 }
78087
78088
78089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78090   int jresult ;
78091   int result;
78092
78093   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78094   jresult = (int)result;
78095   return jresult;
78096 }
78097
78098
78099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78100   int jresult ;
78101   int result;
78102
78103   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78104   jresult = (int)result;
78105   return jresult;
78106 }
78107
78108
78109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78110   int jresult ;
78111   int result;
78112
78113   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78114   jresult = (int)result;
78115   return jresult;
78116 }
78117
78118
78119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78120   void * jresult ;
78121   Dali::Toolkit::TextEditor::Property *result = 0 ;
78122
78123   {
78124     try {
78125       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78126     } catch (std::out_of_range& e) {
78127       {
78128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78129       };
78130     } catch (std::exception& e) {
78131       {
78132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78133       };
78134     } catch (...) {
78135       {
78136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78137       };
78138     }
78139   }
78140   jresult = (void *)result;
78141   return jresult;
78142 }
78143
78144
78145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78146   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78147
78148   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78149   {
78150     try {
78151       delete arg1;
78152     } catch (std::out_of_range& e) {
78153       {
78154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78155       };
78156     } catch (std::exception& e) {
78157       {
78158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78159       };
78160     } catch (...) {
78161       {
78162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78163       };
78164     }
78165   }
78166 }
78167
78168
78169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78170   void * jresult ;
78171   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78172
78173   {
78174     try {
78175       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78176     } catch (std::out_of_range& e) {
78177       {
78178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78179       };
78180     } catch (std::exception& e) {
78181       {
78182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78183       };
78184     } catch (...) {
78185       {
78186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78187       };
78188     }
78189   }
78190   jresult = (void *)result;
78191   return jresult;
78192 }
78193
78194
78195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78196   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78197
78198   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78199   {
78200     try {
78201       delete arg1;
78202     } catch (std::out_of_range& e) {
78203       {
78204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78205       };
78206     } catch (std::exception& e) {
78207       {
78208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78209       };
78210     } catch (...) {
78211       {
78212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78213       };
78214     }
78215   }
78216 }
78217
78218
78219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78220   void * jresult ;
78221   Dali::Toolkit::TextEditor result;
78222
78223   {
78224     try {
78225       result = Dali::Toolkit::TextEditor::New();
78226     } catch (std::out_of_range& e) {
78227       {
78228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78229       };
78230     } catch (std::exception& e) {
78231       {
78232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78233       };
78234     } catch (...) {
78235       {
78236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78237       };
78238     }
78239   }
78240   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78241   return jresult;
78242 }
78243
78244
78245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78246   void * jresult ;
78247   Dali::Toolkit::TextEditor *result = 0 ;
78248
78249   {
78250     try {
78251       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78252     } catch (std::out_of_range& e) {
78253       {
78254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78255       };
78256     } catch (std::exception& e) {
78257       {
78258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (...) {
78261       {
78262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78263       };
78264     }
78265   }
78266   jresult = (void *)result;
78267   return jresult;
78268 }
78269
78270
78271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78272   void * jresult ;
78273   Dali::Toolkit::TextEditor *arg1 = 0 ;
78274   Dali::Toolkit::TextEditor *result = 0 ;
78275
78276   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78277   if (!arg1) {
78278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78279     return 0;
78280   }
78281   {
78282     try {
78283       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78284     } catch (std::out_of_range& e) {
78285       {
78286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78287       };
78288     } catch (std::exception& e) {
78289       {
78290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78291       };
78292     } catch (...) {
78293       {
78294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78295       };
78296     }
78297   }
78298   jresult = (void *)result;
78299   return jresult;
78300 }
78301
78302
78303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78304   void * jresult ;
78305   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78306   Dali::Toolkit::TextEditor *arg2 = 0 ;
78307   Dali::Toolkit::TextEditor *result = 0 ;
78308
78309   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78310   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78311   if (!arg2) {
78312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78313     return 0;
78314   }
78315   {
78316     try {
78317       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78318     } catch (std::out_of_range& e) {
78319       {
78320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78321       };
78322     } catch (std::exception& e) {
78323       {
78324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78325       };
78326     } catch (...) {
78327       {
78328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78329       };
78330     }
78331   }
78332   jresult = (void *)result;
78333   return jresult;
78334 }
78335
78336
78337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78338   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78339
78340   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78341   {
78342     try {
78343       delete arg1;
78344     } catch (std::out_of_range& e) {
78345       {
78346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78347       };
78348     } catch (std::exception& e) {
78349       {
78350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78351       };
78352     } catch (...) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78355       };
78356     }
78357   }
78358 }
78359
78360
78361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78362   void * jresult ;
78363   Dali::BaseHandle arg1 ;
78364   Dali::BaseHandle *argp1 ;
78365   Dali::Toolkit::TextEditor result;
78366
78367   argp1 = (Dali::BaseHandle *)jarg1;
78368   if (!argp1) {
78369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78370     return 0;
78371   }
78372   arg1 = *argp1;
78373   {
78374     try {
78375       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78376     } catch (std::out_of_range& e) {
78377       {
78378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78379       };
78380     } catch (std::exception& e) {
78381       {
78382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78387       };
78388     }
78389   }
78390   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78391   return jresult;
78392 }
78393
78394
78395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78396   void * jresult ;
78397   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78398   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78399
78400   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78401   {
78402     try {
78403       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78404     } catch (std::out_of_range& e) {
78405       {
78406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78407       };
78408     } catch (std::exception& e) {
78409       {
78410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78411       };
78412     } catch (...) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78415       };
78416     }
78417   }
78418   jresult = (void *)result;
78419   return jresult;
78420 }
78421
78422
78423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78424   void * jresult ;
78425   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78426   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78427
78428   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78429   {
78430     try {
78431       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78432     } catch (std::out_of_range& e) {
78433       {
78434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78435       };
78436     } catch (std::exception& e) {
78437       {
78438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78439       };
78440     } catch (...) {
78441       {
78442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78443       };
78444     }
78445   }
78446   jresult = (void *)result;
78447   return jresult;
78448 }
78449
78450
78451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78452   int jresult ;
78453   int result;
78454
78455   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78456   jresult = (int)result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78462   int jresult ;
78463   int result;
78464
78465   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78466   jresult = (int)result;
78467   return jresult;
78468 }
78469
78470
78471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78472   int jresult ;
78473   int result;
78474
78475   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78476   jresult = (int)result;
78477   return jresult;
78478 }
78479
78480
78481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78482   int jresult ;
78483   int result;
78484
78485   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78486   jresult = (int)result;
78487   return jresult;
78488 }
78489
78490
78491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78492   int jresult ;
78493   int result;
78494
78495   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78496   jresult = (int)result;
78497   return jresult;
78498 }
78499
78500
78501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78502   int jresult ;
78503   int result;
78504
78505   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78506   jresult = (int)result;
78507   return jresult;
78508 }
78509
78510
78511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78512   int jresult ;
78513   int result;
78514
78515   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78516   jresult = (int)result;
78517   return jresult;
78518 }
78519
78520
78521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78522   int jresult ;
78523   int result;
78524
78525   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78526   jresult = (int)result;
78527   return jresult;
78528 }
78529
78530
78531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78532   int jresult ;
78533   int result;
78534
78535   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78536   jresult = (int)result;
78537   return jresult;
78538 }
78539
78540
78541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78542   int jresult ;
78543   int result;
78544
78545   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78546   jresult = (int)result;
78547   return jresult;
78548 }
78549
78550
78551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78552   int jresult ;
78553   int result;
78554
78555   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78556   jresult = (int)result;
78557   return jresult;
78558 }
78559
78560
78561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78562   int jresult ;
78563   int result;
78564
78565   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78566   jresult = (int)result;
78567   return jresult;
78568 }
78569
78570
78571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78572   int jresult ;
78573   int result;
78574
78575   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78576   jresult = (int)result;
78577   return jresult;
78578 }
78579
78580
78581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78582   int jresult ;
78583   int result;
78584
78585   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78586   jresult = (int)result;
78587   return jresult;
78588 }
78589
78590
78591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78592   int jresult ;
78593   int result;
78594
78595   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78596   jresult = (int)result;
78597   return jresult;
78598 }
78599
78600
78601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78602   int jresult ;
78603   int result;
78604
78605   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78606   jresult = (int)result;
78607   return jresult;
78608 }
78609
78610
78611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78612   int jresult ;
78613   int result;
78614
78615   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78616   jresult = (int)result;
78617   return jresult;
78618 }
78619
78620
78621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78622   int jresult ;
78623   int result;
78624
78625   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78626   jresult = (int)result;
78627   return jresult;
78628 }
78629
78630
78631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78632   int jresult ;
78633   int result;
78634
78635   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78636   jresult = (int)result;
78637   return jresult;
78638 }
78639
78640
78641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78642   int jresult ;
78643   int result;
78644
78645   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78646   jresult = (int)result;
78647   return jresult;
78648 }
78649
78650
78651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78652   int jresult ;
78653   int result;
78654
78655   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78656   jresult = (int)result;
78657   return jresult;
78658 }
78659
78660
78661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78662   int jresult ;
78663   int result;
78664
78665   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78666   jresult = (int)result;
78667   return jresult;
78668 }
78669
78670
78671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78672   int jresult ;
78673   int result;
78674
78675   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78676   jresult = (int)result;
78677   return jresult;
78678 }
78679
78680
78681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78682   int jresult ;
78683   int result;
78684
78685   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78686   jresult = (int)result;
78687   return jresult;
78688 }
78689
78690
78691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78692   int jresult ;
78693   int result;
78694
78695   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78696   jresult = (int)result;
78697   return jresult;
78698 }
78699
78700
78701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78702   int jresult ;
78703   int result;
78704
78705   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78706   jresult = (int)result;
78707   return jresult;
78708 }
78709
78710
78711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78712   int jresult ;
78713   int result;
78714
78715   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78716   jresult = (int)result;
78717   return jresult;
78718 }
78719
78720
78721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78722   int jresult ;
78723   int result;
78724
78725   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78726   jresult = (int)result;
78727   return jresult;
78728 }
78729
78730
78731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78732   int jresult ;
78733   int result;
78734
78735   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78736   jresult = (int)result;
78737   return jresult;
78738 }
78739
78740
78741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78742   int jresult ;
78743   int result;
78744
78745   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78746   jresult = (int)result;
78747   return jresult;
78748 }
78749
78750
78751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78752   int jresult ;
78753   int result;
78754
78755   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78756   jresult = (int)result;
78757   return jresult;
78758 }
78759
78760
78761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78762   int jresult ;
78763   int result;
78764
78765   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78766   jresult = (int)result;
78767   return jresult;
78768 }
78769
78770
78771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78772   int jresult ;
78773   int result;
78774
78775   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78776   jresult = (int)result;
78777   return jresult;
78778 }
78779
78780
78781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78782   int jresult ;
78783   int result;
78784
78785   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78786   jresult = (int)result;
78787   return jresult;
78788 }
78789
78790
78791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78792   int jresult ;
78793   int result;
78794
78795   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78796   jresult = (int)result;
78797   return jresult;
78798 }
78799
78800
78801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78802   int jresult ;
78803   int result;
78804
78805   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78806   jresult = (int)result;
78807   return jresult;
78808 }
78809
78810
78811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78812   int jresult ;
78813   int result;
78814
78815   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78816   jresult = (int)result;
78817   return jresult;
78818 }
78819
78820
78821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78822   int jresult ;
78823   int result;
78824
78825   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78826   jresult = (int)result;
78827   return jresult;
78828 }
78829
78830
78831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78832   int jresult ;
78833   int result;
78834
78835   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78836   jresult = (int)result;
78837   return jresult;
78838 }
78839
78840
78841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78842   int jresult ;
78843   int result;
78844
78845   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78846   jresult = (int)result;
78847   return jresult;
78848 }
78849
78850
78851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78852   int jresult ;
78853   int result;
78854
78855   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78856   jresult = (int)result;
78857   return jresult;
78858 }
78859
78860
78861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78862   int jresult ;
78863   int result;
78864
78865   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78866   jresult = (int)result;
78867   return jresult;
78868 }
78869
78870
78871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78872   int jresult ;
78873   int result;
78874
78875   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78876   jresult = (int)result;
78877   return jresult;
78878 }
78879
78880
78881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78882   int jresult ;
78883   int result;
78884
78885   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78886   jresult = (int)result;
78887   return jresult;
78888 }
78889
78890
78891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78892   int jresult ;
78893   int result;
78894
78895   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78896   jresult = (int)result;
78897   return jresult;
78898 }
78899
78900
78901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78902   int jresult ;
78903   int result;
78904
78905   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78906   jresult = (int)result;
78907   return jresult;
78908 }
78909
78910
78911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78912   int jresult ;
78913   int result;
78914
78915   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78916   jresult = (int)result;
78917   return jresult;
78918 }
78919
78920
78921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78922   void * jresult ;
78923   Dali::Toolkit::TextField::Property *result = 0 ;
78924
78925   {
78926     try {
78927       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78928     } catch (std::out_of_range& e) {
78929       {
78930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78931       };
78932     } catch (std::exception& e) {
78933       {
78934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78935       };
78936     } catch (...) {
78937       {
78938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78939       };
78940     }
78941   }
78942   jresult = (void *)result;
78943   return jresult;
78944 }
78945
78946
78947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78948   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78949
78950   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78951   {
78952     try {
78953       delete arg1;
78954     } catch (std::out_of_range& e) {
78955       {
78956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78957       };
78958     } catch (std::exception& e) {
78959       {
78960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78961       };
78962     } catch (...) {
78963       {
78964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78965       };
78966     }
78967   }
78968 }
78969
78970
78971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78972   void * jresult ;
78973   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78974
78975   {
78976     try {
78977       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78978     } catch (std::out_of_range& e) {
78979       {
78980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (std::exception& e) {
78983       {
78984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78989       };
78990     }
78991   }
78992   jresult = (void *)result;
78993   return jresult;
78994 }
78995
78996
78997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78998   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78999
79000   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
79001   {
79002     try {
79003       delete arg1;
79004     } catch (std::out_of_range& e) {
79005       {
79006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79007       };
79008     } catch (std::exception& e) {
79009       {
79010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79011       };
79012     } catch (...) {
79013       {
79014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79015       };
79016     }
79017   }
79018 }
79019
79020
79021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
79022   void * jresult ;
79023   Dali::Toolkit::TextField result;
79024
79025   {
79026     try {
79027       result = Dali::Toolkit::TextField::New();
79028     } catch (std::out_of_range& e) {
79029       {
79030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79031       };
79032     } catch (std::exception& e) {
79033       {
79034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79035       };
79036     } catch (...) {
79037       {
79038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79039       };
79040     }
79041   }
79042   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79043   return jresult;
79044 }
79045
79046
79047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
79048   void * jresult ;
79049   Dali::Toolkit::TextField *result = 0 ;
79050
79051   {
79052     try {
79053       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
79054     } catch (std::out_of_range& e) {
79055       {
79056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79057       };
79058     } catch (std::exception& e) {
79059       {
79060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79061       };
79062     } catch (...) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79065       };
79066     }
79067   }
79068   jresult = (void *)result;
79069   return jresult;
79070 }
79071
79072
79073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
79074   void * jresult ;
79075   Dali::Toolkit::TextField *arg1 = 0 ;
79076   Dali::Toolkit::TextField *result = 0 ;
79077
79078   arg1 = (Dali::Toolkit::TextField *)jarg1;
79079   if (!arg1) {
79080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79081     return 0;
79082   }
79083   {
79084     try {
79085       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79086     } catch (std::out_of_range& e) {
79087       {
79088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79089       };
79090     } catch (std::exception& e) {
79091       {
79092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (...) {
79095       {
79096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79097       };
79098     }
79099   }
79100   jresult = (void *)result;
79101   return jresult;
79102 }
79103
79104
79105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79106   void * jresult ;
79107   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79108   Dali::Toolkit::TextField *arg2 = 0 ;
79109   Dali::Toolkit::TextField *result = 0 ;
79110
79111   arg1 = (Dali::Toolkit::TextField *)jarg1;
79112   arg2 = (Dali::Toolkit::TextField *)jarg2;
79113   if (!arg2) {
79114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79115     return 0;
79116   }
79117   {
79118     try {
79119       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79120     } catch (std::out_of_range& e) {
79121       {
79122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79123       };
79124     } catch (std::exception& e) {
79125       {
79126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79127       };
79128     } catch (...) {
79129       {
79130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79131       };
79132     }
79133   }
79134   jresult = (void *)result;
79135   return jresult;
79136 }
79137
79138
79139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79140   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79141
79142   arg1 = (Dali::Toolkit::TextField *)jarg1;
79143   {
79144     try {
79145       delete arg1;
79146     } catch (std::out_of_range& e) {
79147       {
79148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79149       };
79150     } catch (std::exception& e) {
79151       {
79152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79153       };
79154     } catch (...) {
79155       {
79156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79157       };
79158     }
79159   }
79160 }
79161
79162
79163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79164   void * jresult ;
79165   Dali::BaseHandle arg1 ;
79166   Dali::BaseHandle *argp1 ;
79167   Dali::Toolkit::TextField result;
79168
79169   argp1 = (Dali::BaseHandle *)jarg1;
79170   if (!argp1) {
79171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79172     return 0;
79173   }
79174   arg1 = *argp1;
79175   {
79176     try {
79177       result = Dali::Toolkit::TextField::DownCast(arg1);
79178     } catch (std::out_of_range& e) {
79179       {
79180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79181       };
79182     } catch (std::exception& e) {
79183       {
79184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79185       };
79186     } catch (...) {
79187       {
79188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79189       };
79190     }
79191   }
79192   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79193   return jresult;
79194 }
79195
79196
79197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79198   void * jresult ;
79199   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79200   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79201
79202   arg1 = (Dali::Toolkit::TextField *)jarg1;
79203   {
79204     try {
79205       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79206     } catch (std::out_of_range& e) {
79207       {
79208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79209       };
79210     } catch (std::exception& e) {
79211       {
79212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79213       };
79214     } catch (...) {
79215       {
79216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79217       };
79218     }
79219   }
79220   jresult = (void *)result;
79221   return jresult;
79222 }
79223
79224
79225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79226   void * jresult ;
79227   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79228   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79229
79230   arg1 = (Dali::Toolkit::TextField *)jarg1;
79231   {
79232     try {
79233       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79234     } catch (std::out_of_range& e) {
79235       {
79236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79237       };
79238     } catch (std::exception& e) {
79239       {
79240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (...) {
79243       {
79244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79245       };
79246     }
79247   }
79248   jresult = (void *)result;
79249   return jresult;
79250 }
79251
79252
79253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79254   void * jresult ;
79255   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79256   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79257
79258   arg1 = (Dali::Toolkit::TextField *)jarg1;
79259   {
79260     try {
79261       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79262     } catch (std::out_of_range& e) {
79263       {
79264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79265       };
79266     } catch (std::exception& e) {
79267       {
79268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (...) {
79271       {
79272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79273       };
79274     }
79275   }
79276   jresult = (void *)result;
79277   return jresult;
79278 }
79279
79280
79281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79282   int jresult ;
79283   int result;
79284
79285   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79286   jresult = (int)result;
79287   return jresult;
79288 }
79289
79290
79291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79292   int jresult ;
79293   int result;
79294
79295   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79296   jresult = (int)result;
79297   return jresult;
79298 }
79299
79300
79301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79302   int jresult ;
79303   int result;
79304
79305   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79306   jresult = (int)result;
79307   return jresult;
79308 }
79309
79310
79311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79312   int jresult ;
79313   int result;
79314
79315   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79316   jresult = (int)result;
79317   return jresult;
79318 }
79319
79320
79321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79322   int jresult ;
79323   int result;
79324
79325   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79326   jresult = (int)result;
79327   return jresult;
79328 }
79329
79330
79331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79332   int jresult ;
79333   int result;
79334
79335   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79336   jresult = (int)result;
79337   return jresult;
79338 }
79339
79340
79341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79342   int jresult ;
79343   int result;
79344
79345   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79346   jresult = (int)result;
79347   return jresult;
79348 }
79349
79350
79351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79352   int jresult ;
79353   int result;
79354
79355   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79356   jresult = (int)result;
79357   return jresult;
79358 }
79359
79360
79361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79362   int jresult ;
79363   int result;
79364
79365   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79366   jresult = (int)result;
79367   return jresult;
79368 }
79369
79370
79371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79372   int jresult ;
79373   int result;
79374
79375   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79376   jresult = (int)result;
79377   return jresult;
79378 }
79379
79380
79381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79382   int jresult ;
79383   int result;
79384
79385   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79386   jresult = (int)result;
79387   return jresult;
79388 }
79389
79390
79391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79392   int jresult ;
79393   int result;
79394
79395   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79396   jresult = (int)result;
79397   return jresult;
79398 }
79399
79400
79401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79402   int jresult ;
79403   int result;
79404
79405   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79406   jresult = (int)result;
79407   return jresult;
79408 }
79409
79410
79411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79412   int jresult ;
79413   int result;
79414
79415   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79416   jresult = (int)result;
79417   return jresult;
79418 }
79419
79420
79421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79422   int jresult ;
79423   int result;
79424
79425   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79426   jresult = (int)result;
79427   return jresult;
79428 }
79429
79430
79431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79432   int jresult ;
79433   int result;
79434
79435   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79436   jresult = (int)result;
79437   return jresult;
79438 }
79439
79440
79441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79442   int jresult ;
79443   int result;
79444
79445   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79446   jresult = (int)result;
79447   return jresult;
79448 }
79449
79450
79451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79452   int jresult ;
79453   int result;
79454
79455   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79456   jresult = (int)result;
79457   return jresult;
79458 }
79459
79460
79461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79462   int jresult ;
79463   int result;
79464
79465   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79466   jresult = (int)result;
79467   return jresult;
79468 }
79469
79470
79471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79472   int jresult ;
79473   int result;
79474
79475   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79476   jresult = (int)result;
79477   return jresult;
79478 }
79479
79480
79481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79482   int jresult ;
79483   int result;
79484
79485   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79486   jresult = (int)result;
79487   return jresult;
79488 }
79489
79490
79491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79492   int jresult ;
79493   int result;
79494
79495   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79496   jresult = (int)result;
79497   return jresult;
79498 }
79499
79500
79501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79502   int jresult ;
79503   int result;
79504
79505   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79506   jresult = (int)result;
79507   return jresult;
79508 }
79509
79510
79511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79512   int jresult ;
79513   int result;
79514
79515   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79516   jresult = (int)result;
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79522   void * jresult ;
79523   Dali::Toolkit::TextLabel::Property *result = 0 ;
79524
79525   {
79526     try {
79527       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79528     } catch (std::out_of_range& e) {
79529       {
79530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79531       };
79532     } catch (std::exception& e) {
79533       {
79534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79535       };
79536     } catch (...) {
79537       {
79538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79539       };
79540     }
79541   }
79542   jresult = (void *)result;
79543   return jresult;
79544 }
79545
79546
79547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79548   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79549
79550   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79551   {
79552     try {
79553       delete arg1;
79554     } catch (std::out_of_range& e) {
79555       {
79556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79557       };
79558     } catch (std::exception& e) {
79559       {
79560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79561       };
79562     } catch (...) {
79563       {
79564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79565       };
79566     }
79567   }
79568 }
79569
79570
79571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79572   void * jresult ;
79573   Dali::Toolkit::TextLabel result;
79574
79575   {
79576     try {
79577       result = Dali::Toolkit::TextLabel::New();
79578     } catch (std::out_of_range& e) {
79579       {
79580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79581       };
79582     } catch (std::exception& e) {
79583       {
79584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79585       };
79586     } catch (...) {
79587       {
79588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79589       };
79590     }
79591   }
79592   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79593   return jresult;
79594 }
79595
79596
79597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79598   void * jresult ;
79599   std::string *arg1 = 0 ;
79600   Dali::Toolkit::TextLabel result;
79601
79602   if (!jarg1) {
79603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79604     return 0;
79605   }
79606   std::string arg1_str(jarg1);
79607   arg1 = &arg1_str;
79608   {
79609     try {
79610       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79611     } catch (std::out_of_range& e) {
79612       {
79613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79614       };
79615     } catch (std::exception& e) {
79616       {
79617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79618       };
79619     } catch (...) {
79620       {
79621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79622       };
79623     }
79624   }
79625   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79626
79627   //argout typemap for const std::string&
79628
79629   return jresult;
79630 }
79631
79632
79633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79634   void * jresult ;
79635   Dali::Toolkit::TextLabel *result = 0 ;
79636
79637   {
79638     try {
79639       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79640     } catch (std::out_of_range& e) {
79641       {
79642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79643       };
79644     } catch (std::exception& e) {
79645       {
79646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79647       };
79648     } catch (...) {
79649       {
79650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79651       };
79652     }
79653   }
79654   jresult = (void *)result;
79655   return jresult;
79656 }
79657
79658
79659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79660   void * jresult ;
79661   Dali::Toolkit::TextLabel *arg1 = 0 ;
79662   Dali::Toolkit::TextLabel *result = 0 ;
79663
79664   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79665   if (!arg1) {
79666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79667     return 0;
79668   }
79669   {
79670     try {
79671       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79672     } catch (std::out_of_range& e) {
79673       {
79674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79675       };
79676     } catch (std::exception& e) {
79677       {
79678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79679       };
79680     } catch (...) {
79681       {
79682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79683       };
79684     }
79685   }
79686   jresult = (void *)result;
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79692   void * jresult ;
79693   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79694   Dali::Toolkit::TextLabel *arg2 = 0 ;
79695   Dali::Toolkit::TextLabel *result = 0 ;
79696
79697   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79698   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79699   if (!arg2) {
79700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79701     return 0;
79702   }
79703   {
79704     try {
79705       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79706     } catch (std::out_of_range& e) {
79707       {
79708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79709       };
79710     } catch (std::exception& e) {
79711       {
79712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79713       };
79714     } catch (...) {
79715       {
79716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79717       };
79718     }
79719   }
79720   jresult = (void *)result;
79721   return jresult;
79722 }
79723
79724
79725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79726   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79727
79728   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79729   {
79730     try {
79731       delete arg1;
79732     } catch (std::out_of_range& e) {
79733       {
79734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79735       };
79736     } catch (std::exception& e) {
79737       {
79738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79739       };
79740     } catch (...) {
79741       {
79742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79743       };
79744     }
79745   }
79746 }
79747
79748
79749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79750   void * jresult ;
79751   Dali::BaseHandle arg1 ;
79752   Dali::BaseHandle *argp1 ;
79753   Dali::Toolkit::TextLabel result;
79754
79755   argp1 = (Dali::BaseHandle *)jarg1;
79756   if (!argp1) {
79757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79758     return 0;
79759   }
79760   arg1 = *argp1;
79761   {
79762     try {
79763       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79764     } catch (std::out_of_range& e) {
79765       {
79766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79767       };
79768     } catch (std::exception& e) {
79769       {
79770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79771       };
79772     } catch (...) {
79773       {
79774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79775       };
79776     }
79777   }
79778   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79779   return jresult;
79780 }
79781
79782
79783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79784   void * jresult ;
79785   Dali::Toolkit::AccessibilityManager *result = 0 ;
79786
79787   {
79788     try {
79789       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79790     } catch (std::out_of_range& e) {
79791       {
79792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79793       };
79794     } catch (std::exception& e) {
79795       {
79796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79797       };
79798     } catch (...) {
79799       {
79800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79801       };
79802     }
79803   }
79804   jresult = (void *)result;
79805   return jresult;
79806 }
79807
79808
79809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79811
79812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79813   {
79814     try {
79815       delete arg1;
79816     } catch (std::out_of_range& e) {
79817       {
79818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79819       };
79820     } catch (std::exception& e) {
79821       {
79822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79823       };
79824     } catch (...) {
79825       {
79826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79827       };
79828     }
79829   }
79830 }
79831
79832
79833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79834   void * jresult ;
79835   Dali::Toolkit::AccessibilityManager result;
79836
79837   {
79838     try {
79839       result = Dali::Toolkit::AccessibilityManager::Get();
79840     } catch (std::out_of_range& e) {
79841       {
79842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79843       };
79844     } catch (std::exception& e) {
79845       {
79846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (...) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79851       };
79852     }
79853   }
79854   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79855   return jresult;
79856 }
79857
79858
79859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79860   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79861   Dali::Actor arg2 ;
79862   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79863   std::string *arg4 = 0 ;
79864   Dali::Actor *argp2 ;
79865
79866   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79867   argp2 = (Dali::Actor *)jarg2;
79868   if (!argp2) {
79869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79870     return ;
79871   }
79872   arg2 = *argp2;
79873   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79874   if (!jarg4) {
79875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79876     return ;
79877   }
79878   std::string arg4_str(jarg4);
79879   arg4 = &arg4_str;
79880   {
79881     try {
79882       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79883     } catch (std::out_of_range& e) {
79884       {
79885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79886       };
79887     } catch (std::exception& e) {
79888       {
79889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79890       };
79891     } catch (...) {
79892       {
79893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79894       };
79895     }
79896   }
79897
79898   //argout typemap for const std::string&
79899
79900 }
79901
79902
79903 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79904   char * jresult ;
79905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79906   Dali::Actor arg2 ;
79907   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79908   Dali::Actor *argp2 ;
79909   std::string result;
79910
79911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79912   argp2 = (Dali::Actor *)jarg2;
79913   if (!argp2) {
79914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79915     return 0;
79916   }
79917   arg2 = *argp2;
79918   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79919   {
79920     try {
79921       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79922     } catch (std::out_of_range& e) {
79923       {
79924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79925       };
79926     } catch (std::exception& e) {
79927       {
79928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79929       };
79930     } catch (...) {
79931       {
79932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79933       };
79934     }
79935   }
79936   jresult = SWIG_csharp_string_callback((&result)->c_str());
79937   return jresult;
79938 }
79939
79940
79941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79943   Dali::Actor arg2 ;
79944   unsigned int arg3 ;
79945   Dali::Actor *argp2 ;
79946
79947   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79948   argp2 = (Dali::Actor *)jarg2;
79949   if (!argp2) {
79950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79951     return ;
79952   }
79953   arg2 = *argp2;
79954   arg3 = (unsigned int)jarg3;
79955   {
79956     try {
79957       (arg1)->SetFocusOrder(arg2,arg3);
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79976   unsigned int jresult ;
79977   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79978   Dali::Actor arg2 ;
79979   Dali::Actor *argp2 ;
79980   unsigned int result;
79981
79982   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79983   argp2 = (Dali::Actor *)jarg2;
79984   if (!argp2) {
79985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79986     return 0;
79987   }
79988   arg2 = *argp2;
79989   {
79990     try {
79991       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79992     } catch (std::out_of_range& e) {
79993       {
79994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79995       };
79996     } catch (std::exception& e) {
79997       {
79998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79999       };
80000     } catch (...) {
80001       {
80002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80003       };
80004     }
80005   }
80006   jresult = result;
80007   return jresult;
80008 }
80009
80010
80011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80012   unsigned int jresult ;
80013   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80014   unsigned int result;
80015
80016   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80017   {
80018     try {
80019       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80020     } catch (std::out_of_range& e) {
80021       {
80022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80023       };
80024     } catch (std::exception& e) {
80025       {
80026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80027       };
80028     } catch (...) {
80029       {
80030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80031       };
80032     }
80033   }
80034   jresult = result;
80035   return jresult;
80036 }
80037
80038
80039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80040   void * jresult ;
80041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80042   unsigned int arg2 ;
80043   Dali::Actor result;
80044
80045   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80046   arg2 = (unsigned int)jarg2;
80047   {
80048     try {
80049       result = (arg1)->GetActorByFocusOrder(arg2);
80050     } catch (std::out_of_range& e) {
80051       {
80052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80053       };
80054     } catch (std::exception& e) {
80055       {
80056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80057       };
80058     } catch (...) {
80059       {
80060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80061       };
80062     }
80063   }
80064   jresult = new Dali::Actor((const Dali::Actor &)result);
80065   return jresult;
80066 }
80067
80068
80069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80070   unsigned int jresult ;
80071   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80072   Dali::Actor arg2 ;
80073   Dali::Actor *argp2 ;
80074   bool result;
80075
80076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80077   argp2 = (Dali::Actor *)jarg2;
80078   if (!argp2) {
80079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80080     return 0;
80081   }
80082   arg2 = *argp2;
80083   {
80084     try {
80085       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80086     } catch (std::out_of_range& e) {
80087       {
80088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80089       };
80090     } catch (std::exception& e) {
80091       {
80092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80093       };
80094     } catch (...) {
80095       {
80096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80097       };
80098     }
80099   }
80100   jresult = result;
80101   return jresult;
80102 }
80103
80104
80105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80106   void * jresult ;
80107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80108   Dali::Actor result;
80109
80110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80111   {
80112     try {
80113       result = (arg1)->GetCurrentFocusActor();
80114     } catch (std::out_of_range& e) {
80115       {
80116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80117       };
80118     } catch (std::exception& e) {
80119       {
80120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80121       };
80122     } catch (...) {
80123       {
80124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80125       };
80126     }
80127   }
80128   jresult = new Dali::Actor((const Dali::Actor &)result);
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80134   void * jresult ;
80135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80136   Dali::Actor result;
80137
80138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80139   {
80140     try {
80141       result = (arg1)->GetCurrentFocusGroup();
80142     } catch (std::out_of_range& e) {
80143       {
80144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80145       };
80146     } catch (std::exception& e) {
80147       {
80148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (...) {
80151       {
80152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80153       };
80154     }
80155   }
80156   jresult = new Dali::Actor((const Dali::Actor &)result);
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80162   unsigned int jresult ;
80163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80164   unsigned int result;
80165
80166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80167   {
80168     try {
80169       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (...) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80181       };
80182     }
80183   }
80184   jresult = result;
80185   return jresult;
80186 }
80187
80188
80189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80190   unsigned int jresult ;
80191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80192   bool result;
80193
80194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80195   {
80196     try {
80197       result = (bool)(arg1)->MoveFocusForward();
80198     } catch (std::out_of_range& e) {
80199       {
80200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80201       };
80202     } catch (std::exception& e) {
80203       {
80204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80205       };
80206     } catch (...) {
80207       {
80208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80209       };
80210     }
80211   }
80212   jresult = result;
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80218   unsigned int jresult ;
80219   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80220   bool result;
80221
80222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80223   {
80224     try {
80225       result = (bool)(arg1)->MoveFocusBackward();
80226     } catch (std::out_of_range& e) {
80227       {
80228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80229       };
80230     } catch (std::exception& e) {
80231       {
80232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80233       };
80234     } catch (...) {
80235       {
80236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80237       };
80238     }
80239   }
80240   jresult = result;
80241   return jresult;
80242 }
80243
80244
80245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80247
80248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80249   {
80250     try {
80251       (arg1)->ClearFocus();
80252     } catch (std::out_of_range& e) {
80253       {
80254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80255       };
80256     } catch (std::exception& e) {
80257       {
80258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80259       };
80260     } catch (...) {
80261       {
80262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80263       };
80264     }
80265   }
80266 }
80267
80268
80269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80271
80272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80273   {
80274     try {
80275       (arg1)->Reset();
80276     } catch (std::out_of_range& e) {
80277       {
80278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80279       };
80280     } catch (std::exception& e) {
80281       {
80282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80283       };
80284     } catch (...) {
80285       {
80286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80287       };
80288     }
80289   }
80290 }
80291
80292
80293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80295   Dali::Actor arg2 ;
80296   bool arg3 ;
80297   Dali::Actor *argp2 ;
80298
80299   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80300   argp2 = (Dali::Actor *)jarg2;
80301   if (!argp2) {
80302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80303     return ;
80304   }
80305   arg2 = *argp2;
80306   arg3 = jarg3 ? true : false;
80307   {
80308     try {
80309       (arg1)->SetFocusGroup(arg2,arg3);
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80317       };
80318     } catch (...) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80321       };
80322     }
80323   }
80324 }
80325
80326
80327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80328   unsigned int jresult ;
80329   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80330   Dali::Actor arg2 ;
80331   Dali::Actor *argp2 ;
80332   bool result;
80333
80334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80335   argp2 = (Dali::Actor *)jarg2;
80336   if (!argp2) {
80337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80338     return 0;
80339   }
80340   arg2 = *argp2;
80341   {
80342     try {
80343       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80344     } catch (std::out_of_range& e) {
80345       {
80346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80347       };
80348     } catch (std::exception& e) {
80349       {
80350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80351       };
80352     } catch (...) {
80353       {
80354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80355       };
80356     }
80357   }
80358   jresult = result;
80359   return jresult;
80360 }
80361
80362
80363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80364   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80365   bool arg2 ;
80366
80367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80368   arg2 = jarg2 ? true : false;
80369   {
80370     try {
80371       (arg1)->SetGroupMode(arg2);
80372     } catch (std::out_of_range& e) {
80373       {
80374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80375       };
80376     } catch (std::exception& e) {
80377       {
80378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80379       };
80380     } catch (...) {
80381       {
80382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80383       };
80384     }
80385   }
80386 }
80387
80388
80389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80390   unsigned int jresult ;
80391   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80392   bool result;
80393
80394   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80395   {
80396     try {
80397       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80398     } catch (std::out_of_range& e) {
80399       {
80400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80401       };
80402     } catch (std::exception& e) {
80403       {
80404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80405       };
80406     } catch (...) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80409       };
80410     }
80411   }
80412   jresult = result;
80413   return jresult;
80414 }
80415
80416
80417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80419   bool arg2 ;
80420
80421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80422   arg2 = jarg2 ? true : false;
80423   {
80424     try {
80425       (arg1)->SetWrapMode(arg2);
80426     } catch (std::out_of_range& e) {
80427       {
80428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80429       };
80430     } catch (std::exception& e) {
80431       {
80432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80433       };
80434     } catch (...) {
80435       {
80436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80437       };
80438     }
80439   }
80440 }
80441
80442
80443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80444   unsigned int jresult ;
80445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80446   bool result;
80447
80448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80449   {
80450     try {
80451       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (...) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80463       };
80464     }
80465   }
80466   jresult = result;
80467   return jresult;
80468 }
80469
80470
80471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80472   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80473   Dali::Actor arg2 ;
80474   Dali::Actor *argp2 ;
80475
80476   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80477   argp2 = (Dali::Actor *)jarg2;
80478   if (!argp2) {
80479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80480     return ;
80481   }
80482   arg2 = *argp2;
80483   {
80484     try {
80485       (arg1)->SetFocusIndicatorActor(arg2);
80486     } catch (std::out_of_range& e) {
80487       {
80488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80489       };
80490     } catch (std::exception& e) {
80491       {
80492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80493       };
80494     } catch (...) {
80495       {
80496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80497       };
80498     }
80499   }
80500 }
80501
80502
80503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80504   void * jresult ;
80505   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80506   Dali::Actor result;
80507
80508   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80509   {
80510     try {
80511       result = (arg1)->GetFocusIndicatorActor();
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (...) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80523       };
80524     }
80525   }
80526   jresult = new Dali::Actor((const Dali::Actor &)result);
80527   return jresult;
80528 }
80529
80530
80531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80532   void * jresult ;
80533   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80534   Dali::Actor arg2 ;
80535   Dali::Actor *argp2 ;
80536   Dali::Actor result;
80537
80538   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80539   argp2 = (Dali::Actor *)jarg2;
80540   if (!argp2) {
80541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80542     return 0;
80543   }
80544   arg2 = *argp2;
80545   {
80546     try {
80547       result = (arg1)->GetFocusGroup(arg2);
80548     } catch (std::out_of_range& e) {
80549       {
80550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (std::exception& e) {
80553       {
80554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (...) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80559       };
80560     }
80561   }
80562   jresult = new Dali::Actor((const Dali::Actor &)result);
80563   return jresult;
80564 }
80565
80566
80567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80568   void * jresult ;
80569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80570   Dali::Vector2 result;
80571
80572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80573   {
80574     try {
80575       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80576     } catch (std::out_of_range& e) {
80577       {
80578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80579       };
80580     } catch (std::exception& e) {
80581       {
80582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80583       };
80584     } catch (...) {
80585       {
80586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80587       };
80588     }
80589   }
80590   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80591   return jresult;
80592 }
80593
80594
80595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80596   void * jresult ;
80597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80598   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80599
80600   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80601   {
80602     try {
80603       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80604     } catch (std::out_of_range& e) {
80605       {
80606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80607       };
80608     } catch (std::exception& e) {
80609       {
80610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80611       };
80612     } catch (...) {
80613       {
80614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80615       };
80616     }
80617   }
80618   jresult = (void *)result;
80619   return jresult;
80620 }
80621
80622
80623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80624   void * jresult ;
80625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80626   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80627
80628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80629   {
80630     try {
80631       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80632     } catch (std::out_of_range& e) {
80633       {
80634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80635       };
80636     } catch (std::exception& e) {
80637       {
80638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80643       };
80644     }
80645   }
80646   jresult = (void *)result;
80647   return jresult;
80648 }
80649
80650
80651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80652   void * jresult ;
80653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80654   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80655
80656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80657   {
80658     try {
80659       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80660     } catch (std::out_of_range& e) {
80661       {
80662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80663       };
80664     } catch (std::exception& e) {
80665       {
80666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80667       };
80668     } catch (...) {
80669       {
80670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80671       };
80672     }
80673   }
80674   jresult = (void *)result;
80675   return jresult;
80676 }
80677
80678
80679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80680   void * jresult ;
80681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80682   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80683
80684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80685   {
80686     try {
80687       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80688     } catch (std::out_of_range& e) {
80689       {
80690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80691       };
80692     } catch (std::exception& e) {
80693       {
80694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80695       };
80696     } catch (...) {
80697       {
80698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80699       };
80700     }
80701   }
80702   jresult = (void *)result;
80703   return jresult;
80704 }
80705
80706
80707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80708   void * jresult ;
80709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80710   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80711
80712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80713   {
80714     try {
80715       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80727       };
80728     }
80729   }
80730   jresult = (void *)result;
80731   return jresult;
80732 }
80733
80734
80735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80736   void * jresult ;
80737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80738   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80739
80740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80741   {
80742     try {
80743       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80744     } catch (std::out_of_range& e) {
80745       {
80746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (std::exception& e) {
80749       {
80750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80755       };
80756     }
80757   }
80758   jresult = (void *)result;
80759   return jresult;
80760 }
80761
80762
80763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80764   void * jresult ;
80765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80766   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80767
80768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80769   {
80770     try {
80771       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80772     } catch (std::out_of_range& e) {
80773       {
80774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80775       };
80776     } catch (std::exception& e) {
80777       {
80778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (...) {
80781       {
80782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80783       };
80784     }
80785   }
80786   jresult = (void *)result;
80787   return jresult;
80788 }
80789
80790
80791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80792   void * jresult ;
80793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80794   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80795
80796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80797   {
80798     try {
80799       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80800     } catch (std::out_of_range& e) {
80801       {
80802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80803       };
80804     } catch (std::exception& e) {
80805       {
80806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80807       };
80808     } catch (...) {
80809       {
80810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80811       };
80812     }
80813   }
80814   jresult = (void *)result;
80815   return jresult;
80816 }
80817
80818
80819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80820   void * jresult ;
80821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80822   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80823
80824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80825   {
80826     try {
80827       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80828     } catch (std::out_of_range& e) {
80829       {
80830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80831       };
80832     } catch (std::exception& e) {
80833       {
80834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80839       };
80840     }
80841   }
80842   jresult = (void *)result;
80843   return jresult;
80844 }
80845
80846
80847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80848   void * jresult ;
80849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80850   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80851
80852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80853   {
80854     try {
80855       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80856     } catch (std::out_of_range& e) {
80857       {
80858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80859       };
80860     } catch (std::exception& e) {
80861       {
80862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80863       };
80864     } catch (...) {
80865       {
80866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80867       };
80868     }
80869   }
80870   jresult = (void *)result;
80871   return jresult;
80872 }
80873
80874
80875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80876   void * jresult ;
80877   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80878   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80879
80880   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80881   {
80882     try {
80883       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80884     } catch (std::out_of_range& e) {
80885       {
80886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80887       };
80888     } catch (std::exception& e) {
80889       {
80890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80891       };
80892     } catch (...) {
80893       {
80894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80895       };
80896     }
80897   }
80898   jresult = (void *)result;
80899   return jresult;
80900 }
80901
80902
80903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80904   void * jresult ;
80905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80906   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80907
80908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80909   {
80910     try {
80911       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80912     } catch (std::out_of_range& e) {
80913       {
80914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80915       };
80916     } catch (std::exception& e) {
80917       {
80918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80919       };
80920     } catch (...) {
80921       {
80922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80923       };
80924     }
80925   }
80926   jresult = (void *)result;
80927   return jresult;
80928 }
80929
80930
80931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80932   void * jresult ;
80933   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80934   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80935
80936   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80937   {
80938     try {
80939       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80940     } catch (std::out_of_range& e) {
80941       {
80942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80943       };
80944     } catch (std::exception& e) {
80945       {
80946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80947       };
80948     } catch (...) {
80949       {
80950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80951       };
80952     }
80953   }
80954   jresult = (void *)result;
80955   return jresult;
80956 }
80957
80958
80959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80960   void * jresult ;
80961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80963
80964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80965   {
80966     try {
80967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80968     } catch (std::out_of_range& e) {
80969       {
80970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80971       };
80972     } catch (std::exception& e) {
80973       {
80974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80979       };
80980     }
80981   }
80982   jresult = (void *)result;
80983   return jresult;
80984 }
80985
80986
80987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80988   void * jresult ;
80989   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80990   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80991
80992   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80993   {
80994     try {
80995       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80996     } catch (std::out_of_range& e) {
80997       {
80998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80999       };
81000     } catch (std::exception& e) {
81001       {
81002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81003       };
81004     } catch (...) {
81005       {
81006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81007       };
81008     }
81009   }
81010   jresult = (void *)result;
81011   return jresult;
81012 }
81013
81014
81015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81016   void * jresult ;
81017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81019
81020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81021   {
81022     try {
81023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81024     } catch (std::out_of_range& e) {
81025       {
81026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81027       };
81028     } catch (std::exception& e) {
81029       {
81030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81031       };
81032     } catch (...) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81035       };
81036     }
81037   }
81038   jresult = (void *)result;
81039   return jresult;
81040 }
81041
81042
81043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81044   void * jresult ;
81045   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81046   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81047
81048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81049   {
81050     try {
81051       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81052     } catch (std::out_of_range& e) {
81053       {
81054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81055       };
81056     } catch (std::exception& e) {
81057       {
81058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81059       };
81060     } catch (...) {
81061       {
81062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81063       };
81064     }
81065   }
81066   jresult = (void *)result;
81067   return jresult;
81068 }
81069
81070
81071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81072   void * jresult ;
81073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81074   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81075
81076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81077   {
81078     try {
81079       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81080     } catch (std::out_of_range& e) {
81081       {
81082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81083       };
81084     } catch (std::exception& e) {
81085       {
81086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81087       };
81088     } catch (...) {
81089       {
81090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81091       };
81092     }
81093   }
81094   jresult = (void *)result;
81095   return jresult;
81096 }
81097
81098
81099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81100   void * jresult ;
81101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81102   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81103
81104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81105   {
81106     try {
81107       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81108     } catch (std::out_of_range& e) {
81109       {
81110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81111       };
81112     } catch (std::exception& e) {
81113       {
81114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81115       };
81116     } catch (...) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81119       };
81120     }
81121   }
81122   jresult = (void *)result;
81123   return jresult;
81124 }
81125
81126
81127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81128   void * jresult ;
81129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81130   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81131
81132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81133   {
81134     try {
81135       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81136     } catch (std::out_of_range& e) {
81137       {
81138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81139       };
81140     } catch (std::exception& e) {
81141       {
81142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81143       };
81144     } catch (...) {
81145       {
81146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81147       };
81148     }
81149   }
81150   jresult = (void *)result;
81151   return jresult;
81152 }
81153
81154
81155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81156   void * jresult ;
81157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81158   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81159
81160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81161   {
81162     try {
81163       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81164     } catch (std::out_of_range& e) {
81165       {
81166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (std::exception& e) {
81169       {
81170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81171       };
81172     } catch (...) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81175       };
81176     }
81177   }
81178   jresult = (void *)result;
81179   return jresult;
81180 }
81181
81182
81183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81184   void * jresult ;
81185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81186   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81187
81188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81189   {
81190     try {
81191       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81192     } catch (std::out_of_range& e) {
81193       {
81194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (std::exception& e) {
81197       {
81198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (...) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81203       };
81204     }
81205   }
81206   jresult = (void *)result;
81207   return jresult;
81208 }
81209
81210
81211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81212   void * jresult ;
81213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81215
81216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81217   {
81218     try {
81219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81220     } catch (std::out_of_range& e) {
81221       {
81222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81223       };
81224     } catch (std::exception& e) {
81225       {
81226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81227       };
81228     } catch (...) {
81229       {
81230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81231       };
81232     }
81233   }
81234   jresult = (void *)result;
81235   return jresult;
81236 }
81237
81238
81239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81240   void * jresult ;
81241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81242   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81243
81244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81245   {
81246     try {
81247       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81248     } catch (std::out_of_range& e) {
81249       {
81250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81251       };
81252     } catch (std::exception& e) {
81253       {
81254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81255       };
81256     } catch (...) {
81257       {
81258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81259       };
81260     }
81261   }
81262   jresult = (void *)result;
81263   return jresult;
81264 }
81265
81266
81267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81268   void * jresult ;
81269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81270   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81271
81272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81273   {
81274     try {
81275       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81276     } catch (std::out_of_range& e) {
81277       {
81278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (std::exception& e) {
81281       {
81282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81283       };
81284     } catch (...) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81287       };
81288     }
81289   }
81290   jresult = (void *)result;
81291   return jresult;
81292 }
81293
81294
81295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81296   void * jresult ;
81297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81298   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81299
81300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81301   {
81302     try {
81303       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (...) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81315       };
81316     }
81317   }
81318   jresult = (void *)result;
81319   return jresult;
81320 }
81321
81322
81323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81324   void * jresult ;
81325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81326   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81327
81328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81329   {
81330     try {
81331       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81332     } catch (std::out_of_range& e) {
81333       {
81334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81335       };
81336     } catch (std::exception& e) {
81337       {
81338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81339       };
81340     } catch (...) {
81341       {
81342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81343       };
81344     }
81345   }
81346   jresult = (void *)result;
81347   return jresult;
81348 }
81349
81350
81351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81352   void * jresult ;
81353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81354   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81355
81356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81357   {
81358     try {
81359       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81360     } catch (std::out_of_range& e) {
81361       {
81362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81363       };
81364     } catch (std::exception& e) {
81365       {
81366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81367       };
81368     } catch (...) {
81369       {
81370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81371       };
81372     }
81373   }
81374   jresult = (void *)result;
81375   return jresult;
81376 }
81377
81378
81379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81380   void * jresult ;
81381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81382   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81383
81384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81385   {
81386     try {
81387       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81388     } catch (std::out_of_range& e) {
81389       {
81390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81391       };
81392     } catch (std::exception& e) {
81393       {
81394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81395       };
81396     } catch (...) {
81397       {
81398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81399       };
81400     }
81401   }
81402   jresult = (void *)result;
81403   return jresult;
81404 }
81405
81406
81407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81408   void * jresult ;
81409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81410   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81411
81412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81413   {
81414     try {
81415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81416     } catch (std::out_of_range& e) {
81417       {
81418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81419       };
81420     } catch (std::exception& e) {
81421       {
81422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81423       };
81424     } catch (...) {
81425       {
81426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81427       };
81428     }
81429   }
81430   jresult = (void *)result;
81431   return jresult;
81432 }
81433
81434
81435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81436   void * jresult ;
81437   Dali::Toolkit::StyleManager *result = 0 ;
81438
81439   {
81440     try {
81441       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81442     } catch (std::out_of_range& e) {
81443       {
81444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81445       };
81446     } catch (std::exception& e) {
81447       {
81448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81449       };
81450     } catch (...) {
81451       {
81452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81453       };
81454     }
81455   }
81456   jresult = (void *)result;
81457   return jresult;
81458 }
81459
81460
81461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81462   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81463
81464   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81465   {
81466     try {
81467       delete arg1;
81468     } catch (std::out_of_range& e) {
81469       {
81470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81471       };
81472     } catch (std::exception& e) {
81473       {
81474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81475       };
81476     } catch (...) {
81477       {
81478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81479       };
81480     }
81481   }
81482 }
81483
81484
81485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81486   void * jresult ;
81487   Dali::Toolkit::StyleManager result;
81488
81489   {
81490     try {
81491       result = Dali::Toolkit::StyleManager::Get();
81492     } catch (std::out_of_range& e) {
81493       {
81494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81495       };
81496     } catch (std::exception& e) {
81497       {
81498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81499       };
81500     } catch (...) {
81501       {
81502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81503       };
81504     }
81505   }
81506   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81507   return jresult;
81508 }
81509
81510
81511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81512   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81513   std::string *arg2 = 0 ;
81514
81515   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81516   if (!jarg2) {
81517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81518     return ;
81519   }
81520   std::string arg2_str(jarg2);
81521   arg2 = &arg2_str;
81522   {
81523     try {
81524       (arg1)->ApplyTheme((std::string const &)*arg2);
81525     } catch (std::out_of_range& e) {
81526       {
81527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81528       };
81529     } catch (std::exception& e) {
81530       {
81531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81532       };
81533     } catch (...) {
81534       {
81535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81536       };
81537     }
81538   }
81539
81540   //argout typemap for const std::string&
81541
81542 }
81543
81544
81545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81546   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81547
81548   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81549   {
81550     try {
81551       (arg1)->ApplyDefaultTheme();
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81563       };
81564     }
81565   }
81566 }
81567
81568
81569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81570   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81571   std::string *arg2 = 0 ;
81572   Dali::Property::Value *arg3 = 0 ;
81573
81574   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81575   if (!jarg2) {
81576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81577     return ;
81578   }
81579   std::string arg2_str(jarg2);
81580   arg2 = &arg2_str;
81581   arg3 = (Dali::Property::Value *)jarg3;
81582   if (!arg3) {
81583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81584     return ;
81585   }
81586   {
81587     try {
81588       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81589     } catch (std::out_of_range& e) {
81590       {
81591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81592       };
81593     } catch (std::exception& e) {
81594       {
81595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81596       };
81597     } catch (...) {
81598       {
81599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81600       };
81601     }
81602   }
81603
81604   //argout typemap for const std::string&
81605
81606 }
81607
81608
81609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81610   unsigned int jresult ;
81611   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81612   std::string *arg2 = 0 ;
81613   Dali::Property::Value *arg3 = 0 ;
81614   bool result;
81615
81616   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81617   if (!jarg2) {
81618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81619     return 0;
81620   }
81621   std::string arg2_str(jarg2);
81622   arg2 = &arg2_str;
81623   arg3 = (Dali::Property::Value *)jarg3;
81624   if (!arg3) {
81625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81626     return 0;
81627   }
81628   {
81629     try {
81630       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81631     } catch (std::out_of_range& e) {
81632       {
81633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81634       };
81635     } catch (std::exception& e) {
81636       {
81637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81638       };
81639     } catch (...) {
81640       {
81641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81642       };
81643     }
81644   }
81645   jresult = result;
81646
81647   //argout typemap for const std::string&
81648
81649   return jresult;
81650 }
81651
81652
81653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81654   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81655   Dali::Toolkit::Control arg2 ;
81656   std::string *arg3 = 0 ;
81657   std::string *arg4 = 0 ;
81658   Dali::Toolkit::Control *argp2 ;
81659
81660   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81661   argp2 = (Dali::Toolkit::Control *)jarg2;
81662   if (!argp2) {
81663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81664     return ;
81665   }
81666   arg2 = *argp2;
81667   if (!jarg3) {
81668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81669     return ;
81670   }
81671   std::string arg3_str(jarg3);
81672   arg3 = &arg3_str;
81673   if (!jarg4) {
81674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81675     return ;
81676   }
81677   std::string arg4_str(jarg4);
81678   arg4 = &arg4_str;
81679   {
81680     try {
81681       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81682     } catch (std::out_of_range& e) {
81683       {
81684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81685       };
81686     } catch (std::exception& e) {
81687       {
81688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81689       };
81690     } catch (...) {
81691       {
81692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81693       };
81694     }
81695   }
81696
81697   //argout typemap for const std::string&
81698
81699
81700   //argout typemap for const std::string&
81701
81702 }
81703
81704
81705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81706   void * jresult ;
81707   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81708   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81709
81710   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81711   {
81712     try {
81713       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81714     } catch (std::out_of_range& e) {
81715       {
81716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81717       };
81718     } catch (std::exception& e) {
81719       {
81720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81725       };
81726     }
81727   }
81728   jresult = (void *)result;
81729   return jresult;
81730 }
81731
81732
81733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81734   int jresult ;
81735   int result;
81736
81737   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81738   jresult = (int)result;
81739   return jresult;
81740 }
81741
81742
81743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81744   int jresult ;
81745   int result;
81746
81747   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81748   jresult = (int)result;
81749   return jresult;
81750 }
81751
81752
81753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81754   int jresult ;
81755   int result;
81756
81757   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81758   jresult = (int)result;
81759   return jresult;
81760 }
81761
81762
81763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81764   int jresult ;
81765   int result;
81766
81767   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81768   jresult = (int)result;
81769   return jresult;
81770 }
81771
81772
81773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81774   int jresult ;
81775   int result;
81776
81777   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81778   jresult = (int)result;
81779   return jresult;
81780 }
81781
81782
81783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81784   int jresult ;
81785   int result;
81786
81787   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81788   jresult = (int)result;
81789   return jresult;
81790 }
81791
81792
81793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81794   int jresult ;
81795   int result;
81796
81797   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81798   jresult = (int)result;
81799   return jresult;
81800 }
81801
81802
81803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81804   int jresult ;
81805   int result;
81806
81807   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81808   jresult = (int)result;
81809   return jresult;
81810 }
81811
81812
81813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81814   int jresult ;
81815   int result;
81816
81817   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81818   jresult = (int)result;
81819   return jresult;
81820 }
81821
81822
81823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81824   int jresult ;
81825   int result;
81826
81827   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81828   jresult = (int)result;
81829   return jresult;
81830 }
81831
81832
81833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81834   int jresult ;
81835   int result;
81836
81837   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81838   jresult = (int)result;
81839   return jresult;
81840 }
81841
81842
81843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81844   int jresult ;
81845   int result;
81846
81847   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81848   jresult = (int)result;
81849   return jresult;
81850 }
81851
81852
81853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81854   int jresult ;
81855   int result;
81856
81857   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81858   jresult = (int)result;
81859   return jresult;
81860 }
81861
81862
81863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81864   int jresult ;
81865   int result;
81866
81867   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81868   jresult = (int)result;
81869   return jresult;
81870 }
81871
81872
81873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81874   int jresult ;
81875   int result;
81876
81877   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81878   jresult = (int)result;
81879   return jresult;
81880 }
81881
81882
81883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81884   void * jresult ;
81885   Dali::Toolkit::Slider::Property *result = 0 ;
81886
81887   {
81888     try {
81889       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81890     } catch (std::out_of_range& e) {
81891       {
81892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81893       };
81894     } catch (std::exception& e) {
81895       {
81896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81901       };
81902     }
81903   }
81904   jresult = (void *)result;
81905   return jresult;
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81910   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81911
81912   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81913   {
81914     try {
81915       delete arg1;
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81923       };
81924     } catch (...) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81927       };
81928     }
81929   }
81930 }
81931
81932
81933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81934   void * jresult ;
81935   Dali::Toolkit::Slider result;
81936
81937   {
81938     try {
81939       result = Dali::Toolkit::Slider::New();
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81947       };
81948     } catch (...) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81951       };
81952     }
81953   }
81954   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81955   return jresult;
81956 }
81957
81958
81959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81960   void * jresult ;
81961   Dali::Toolkit::Slider *result = 0 ;
81962
81963   {
81964     try {
81965       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81966     } catch (std::out_of_range& e) {
81967       {
81968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81969       };
81970     } catch (std::exception& e) {
81971       {
81972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81973       };
81974     } catch (...) {
81975       {
81976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81977       };
81978     }
81979   }
81980   jresult = (void *)result;
81981   return jresult;
81982 }
81983
81984
81985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81986   void * jresult ;
81987   Dali::Toolkit::Slider *arg1 = 0 ;
81988   Dali::Toolkit::Slider *result = 0 ;
81989
81990   arg1 = (Dali::Toolkit::Slider *)jarg1;
81991   if (!arg1) {
81992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81993     return 0;
81994   }
81995   {
81996     try {
81997       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81998     } catch (std::out_of_range& e) {
81999       {
82000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82001       };
82002     } catch (std::exception& e) {
82003       {
82004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82005       };
82006     } catch (...) {
82007       {
82008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82009       };
82010     }
82011   }
82012   jresult = (void *)result;
82013   return jresult;
82014 }
82015
82016
82017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82018   void * jresult ;
82019   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82020   Dali::Toolkit::Slider *arg2 = 0 ;
82021   Dali::Toolkit::Slider *result = 0 ;
82022
82023   arg1 = (Dali::Toolkit::Slider *)jarg1;
82024   arg2 = (Dali::Toolkit::Slider *)jarg2;
82025   if (!arg2) {
82026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82027     return 0;
82028   }
82029   {
82030     try {
82031       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82032     } catch (std::out_of_range& e) {
82033       {
82034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82035       };
82036     } catch (std::exception& e) {
82037       {
82038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82039       };
82040     } catch (...) {
82041       {
82042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82043       };
82044     }
82045   }
82046   jresult = (void *)result;
82047   return jresult;
82048 }
82049
82050
82051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82052   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82053
82054   arg1 = (Dali::Toolkit::Slider *)jarg1;
82055   {
82056     try {
82057       delete arg1;
82058     } catch (std::out_of_range& e) {
82059       {
82060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82061       };
82062     } catch (std::exception& e) {
82063       {
82064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82065       };
82066     } catch (...) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82069       };
82070     }
82071   }
82072 }
82073
82074
82075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82076   void * jresult ;
82077   Dali::BaseHandle arg1 ;
82078   Dali::BaseHandle *argp1 ;
82079   Dali::Toolkit::Slider result;
82080
82081   argp1 = (Dali::BaseHandle *)jarg1;
82082   if (!argp1) {
82083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82084     return 0;
82085   }
82086   arg1 = *argp1;
82087   {
82088     try {
82089       result = Dali::Toolkit::Slider::DownCast(arg1);
82090     } catch (std::out_of_range& e) {
82091       {
82092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82093       };
82094     } catch (std::exception& e) {
82095       {
82096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82097       };
82098     } catch (...) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82101       };
82102     }
82103   }
82104   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82105   return jresult;
82106 }
82107
82108
82109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82110   void * jresult ;
82111   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82112   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82113
82114   arg1 = (Dali::Toolkit::Slider *)jarg1;
82115   {
82116     try {
82117       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82118     } catch (std::out_of_range& e) {
82119       {
82120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82121       };
82122     } catch (std::exception& e) {
82123       {
82124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82125       };
82126     } catch (...) {
82127       {
82128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82129       };
82130     }
82131   }
82132   jresult = (void *)result;
82133   return jresult;
82134 }
82135
82136
82137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82138   void * jresult ;
82139   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82140   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82141
82142   arg1 = (Dali::Toolkit::Slider *)jarg1;
82143   {
82144     try {
82145       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82146     } catch (std::out_of_range& e) {
82147       {
82148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82149       };
82150     } catch (std::exception& e) {
82151       {
82152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (...) {
82155       {
82156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82157       };
82158     }
82159   }
82160   jresult = (void *)result;
82161   return jresult;
82162 }
82163
82164
82165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82166   void * jresult ;
82167   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82168   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82169
82170   arg1 = (Dali::Toolkit::Slider *)jarg1;
82171   {
82172     try {
82173       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82174     } catch (std::out_of_range& e) {
82175       {
82176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82177       };
82178     } catch (std::exception& e) {
82179       {
82180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82181       };
82182     } catch (...) {
82183       {
82184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82185       };
82186     }
82187   }
82188   jresult = (void *)result;
82189   return jresult;
82190 }
82191
82192
82193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82194   int jresult ;
82195   int result;
82196
82197   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82198   jresult = (int)result;
82199   return jresult;
82200 }
82201
82202
82203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82204   int jresult ;
82205   int result;
82206
82207   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82208   jresult = (int)result;
82209   return jresult;
82210 }
82211
82212
82213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82214   int jresult ;
82215   int result;
82216
82217   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82218   jresult = (int)result;
82219   return jresult;
82220 }
82221
82222
82223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82224   int jresult ;
82225   int result;
82226
82227   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82228   jresult = (int)result;
82229   return jresult;
82230 }
82231
82232
82233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82234   void * jresult ;
82235   Dali::Toolkit::VideoView::Property *result = 0 ;
82236
82237   {
82238     try {
82239       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82240     } catch (std::out_of_range& e) {
82241       {
82242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82243       };
82244     } catch (std::exception& e) {
82245       {
82246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82247       };
82248     } catch (...) {
82249       {
82250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82251       };
82252     }
82253   }
82254   jresult = (void *)result;
82255   return jresult;
82256 }
82257
82258
82259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82260   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82261
82262   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82263   {
82264     try {
82265       delete arg1;
82266     } catch (std::out_of_range& e) {
82267       {
82268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82269       };
82270     } catch (std::exception& e) {
82271       {
82272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82273       };
82274     } catch (...) {
82275       {
82276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82277       };
82278     }
82279   }
82280 }
82281
82282
82283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82284   void * jresult ;
82285   Dali::Toolkit::VideoView result;
82286
82287   {
82288     try {
82289       result = Dali::Toolkit::VideoView::New();
82290     } catch (std::out_of_range& e) {
82291       {
82292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82293       };
82294     } catch (std::exception& e) {
82295       {
82296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82297       };
82298     } catch (...) {
82299       {
82300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82301       };
82302     }
82303   }
82304   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82305   return jresult;
82306 }
82307
82308
82309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82310   void * jresult ;
82311   std::string *arg1 = 0 ;
82312   Dali::Toolkit::VideoView result;
82313
82314   if (!jarg1) {
82315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82316     return 0;
82317   }
82318   std::string arg1_str(jarg1);
82319   arg1 = &arg1_str;
82320   {
82321     try {
82322       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82323     } catch (std::out_of_range& e) {
82324       {
82325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82326       };
82327     } catch (std::exception& e) {
82328       {
82329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82330       };
82331     } catch (...) {
82332       {
82333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82334       };
82335     }
82336   }
82337   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82338
82339   //argout typemap for const std::string&
82340
82341   return jresult;
82342 }
82343
82344
82345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82346   void * jresult ;
82347   Dali::Toolkit::VideoView *result = 0 ;
82348
82349   {
82350     try {
82351       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82352     } catch (std::out_of_range& e) {
82353       {
82354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82355       };
82356     } catch (std::exception& e) {
82357       {
82358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82359       };
82360     } catch (...) {
82361       {
82362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82363       };
82364     }
82365   }
82366   jresult = (void *)result;
82367   return jresult;
82368 }
82369
82370
82371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82372   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82373
82374   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82375   {
82376     try {
82377       delete arg1;
82378     } catch (std::out_of_range& e) {
82379       {
82380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82381       };
82382     } catch (std::exception& e) {
82383       {
82384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82385       };
82386     } catch (...) {
82387       {
82388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82389       };
82390     }
82391   }
82392 }
82393
82394
82395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82396   void * jresult ;
82397   Dali::Toolkit::VideoView *arg1 = 0 ;
82398   Dali::Toolkit::VideoView *result = 0 ;
82399
82400   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82401   if (!arg1) {
82402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82403     return 0;
82404   }
82405   {
82406     try {
82407       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82408     } catch (std::out_of_range& e) {
82409       {
82410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (std::exception& e) {
82413       {
82414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (...) {
82417       {
82418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82419       };
82420     }
82421   }
82422   jresult = (void *)result;
82423   return jresult;
82424 }
82425
82426
82427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82428   void * jresult ;
82429   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82430   Dali::Toolkit::VideoView *arg2 = 0 ;
82431   Dali::Toolkit::VideoView *result = 0 ;
82432
82433   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82434   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82435   if (!arg2) {
82436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82437     return 0;
82438   }
82439   {
82440     try {
82441       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82442     } catch (std::out_of_range& e) {
82443       {
82444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82445       };
82446     } catch (std::exception& e) {
82447       {
82448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82449       };
82450     } catch (...) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82453       };
82454     }
82455   }
82456   jresult = (void *)result;
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82462   void * jresult ;
82463   Dali::BaseHandle arg1 ;
82464   Dali::BaseHandle *argp1 ;
82465   Dali::Toolkit::VideoView result;
82466
82467   argp1 = (Dali::BaseHandle *)jarg1;
82468   if (!argp1) {
82469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82470     return 0;
82471   }
82472   arg1 = *argp1;
82473   {
82474     try {
82475       result = Dali::Toolkit::VideoView::DownCast(arg1);
82476     } catch (std::out_of_range& e) {
82477       {
82478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82479       };
82480     } catch (std::exception& e) {
82481       {
82482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82483       };
82484     } catch (...) {
82485       {
82486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82487       };
82488     }
82489   }
82490   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82491   return jresult;
82492 }
82493
82494
82495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82496   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82497
82498   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82499   {
82500     try {
82501       (arg1)->Play();
82502     } catch (std::out_of_range& e) {
82503       {
82504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82505       };
82506     } catch (std::exception& e) {
82507       {
82508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82509       };
82510     } catch (...) {
82511       {
82512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82513       };
82514     }
82515   }
82516 }
82517
82518
82519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82520   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82521
82522   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82523   {
82524     try {
82525       (arg1)->Pause();
82526     } catch (std::out_of_range& e) {
82527       {
82528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82529       };
82530     } catch (std::exception& e) {
82531       {
82532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82533       };
82534     } catch (...) {
82535       {
82536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82537       };
82538     }
82539   }
82540 }
82541
82542
82543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82544   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82545
82546   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82547   {
82548     try {
82549       (arg1)->Stop();
82550     } catch (std::out_of_range& e) {
82551       {
82552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82553       };
82554     } catch (std::exception& e) {
82555       {
82556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82557       };
82558     } catch (...) {
82559       {
82560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82561       };
82562     }
82563   }
82564 }
82565
82566
82567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82568   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82569   int arg2 ;
82570
82571   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82572   arg2 = (int)jarg2;
82573   {
82574     try {
82575       (arg1)->Forward(arg2);
82576     } catch (std::out_of_range& e) {
82577       {
82578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82579       };
82580     } catch (std::exception& e) {
82581       {
82582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82583       };
82584     } catch (...) {
82585       {
82586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82587       };
82588     }
82589   }
82590 }
82591
82592
82593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82594   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82595   int arg2 ;
82596
82597   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82598   arg2 = (int)jarg2;
82599   {
82600     try {
82601       (arg1)->Backward(arg2);
82602     } catch (std::out_of_range& e) {
82603       {
82604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82605       };
82606     } catch (std::exception& e) {
82607       {
82608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82609       };
82610     } catch (...) {
82611       {
82612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82613       };
82614     }
82615   }
82616 }
82617
82618
82619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82620   void * jresult ;
82621   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82622   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82623
82624   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82625   {
82626     try {
82627       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82628     } catch (std::out_of_range& e) {
82629       {
82630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82631       };
82632     } catch (std::exception& e) {
82633       {
82634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82635       };
82636     } catch (...) {
82637       {
82638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82639       };
82640     }
82641   }
82642   jresult = (void *)result;
82643   return jresult;
82644 }
82645
82646
82647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82648   int jresult ;
82649   int result;
82650
82651   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82652   jresult = (int)result;
82653   return jresult;
82654 }
82655
82656
82657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82658   int jresult ;
82659   int result;
82660
82661   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82662   jresult = (int)result;
82663   return jresult;
82664 }
82665
82666
82667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82668   int jresult ;
82669   int result;
82670
82671   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82672   jresult = (int)result;
82673   return jresult;
82674 }
82675
82676
82677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82678   int jresult ;
82679   int result;
82680
82681   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82682   jresult = (int)result;
82683   return jresult;
82684 }
82685
82686
82687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82688   int jresult ;
82689   int result;
82690
82691   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82692   jresult = (int)result;
82693   return jresult;
82694 }
82695
82696
82697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82698   int jresult ;
82699   int result;
82700
82701   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82702   jresult = (int)result;
82703   return jresult;
82704 }
82705
82706
82707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82708   int jresult ;
82709   int result;
82710
82711   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82712   jresult = (int)result;
82713   return jresult;
82714 }
82715
82716
82717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82718   int jresult ;
82719   int result;
82720
82721   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82722   jresult = (int)result;
82723   return jresult;
82724 }
82725
82726
82727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82728   int jresult ;
82729   int result;
82730
82731   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82732   jresult = (int)result;
82733   return jresult;
82734 }
82735
82736
82737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82738   int jresult ;
82739   int result;
82740
82741   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82742   jresult = (int)result;
82743   return jresult;
82744 }
82745
82746
82747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82748   int jresult ;
82749   int result;
82750
82751   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82752   jresult = (int)result;
82753   return jresult;
82754 }
82755
82756
82757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82758   int jresult ;
82759   int result;
82760
82761   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82762   jresult = (int)result;
82763   return jresult;
82764 }
82765
82766
82767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82768   int jresult ;
82769   int result;
82770
82771   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82772   jresult = (int)result;
82773   return jresult;
82774 }
82775
82776
82777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82778   int jresult ;
82779   int result;
82780
82781   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82782   jresult = (int)result;
82783   return jresult;
82784 }
82785
82786
82787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82788   int jresult ;
82789   int result;
82790
82791   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82792   jresult = (int)result;
82793   return jresult;
82794 }
82795
82796
82797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82798   int jresult ;
82799   int result;
82800
82801   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82802   jresult = (int)result;
82803   return jresult;
82804 }
82805
82806
82807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82808   int jresult ;
82809   int result;
82810
82811   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82812   jresult = (int)result;
82813   return jresult;
82814 }
82815
82816
82817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82818   int jresult ;
82819   int result;
82820
82821   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82822   jresult = (int)result;
82823   return jresult;
82824 }
82825
82826
82827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82828   int jresult ;
82829   int result;
82830
82831   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82832   jresult = (int)result;
82833   return jresult;
82834 }
82835
82836
82837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82838   int jresult ;
82839   int result;
82840
82841   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82842   jresult = (int)result;
82843   return jresult;
82844 }
82845
82846
82847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82848   int jresult ;
82849   int result;
82850
82851   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82852   jresult = (int)result;
82853   return jresult;
82854 }
82855
82856
82857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82858   void * jresult ;
82859   Dali::Toolkit::Popup::Property *result = 0 ;
82860
82861   {
82862     try {
82863       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82864     } catch (std::out_of_range& e) {
82865       {
82866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82867       };
82868     } catch (std::exception& e) {
82869       {
82870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82871       };
82872     } catch (...) {
82873       {
82874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82875       };
82876     }
82877   }
82878   jresult = (void *)result;
82879   return jresult;
82880 }
82881
82882
82883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82884   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82885
82886   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82887   {
82888     try {
82889       delete arg1;
82890     } catch (std::out_of_range& e) {
82891       {
82892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82893       };
82894     } catch (std::exception& e) {
82895       {
82896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82897       };
82898     } catch (...) {
82899       {
82900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82901       };
82902     }
82903   }
82904 }
82905
82906
82907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82908   void * jresult ;
82909   Dali::Toolkit::Popup *result = 0 ;
82910
82911   {
82912     try {
82913       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82914     } catch (std::out_of_range& e) {
82915       {
82916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82917       };
82918     } catch (std::exception& e) {
82919       {
82920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82921       };
82922     } catch (...) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82925       };
82926     }
82927   }
82928   jresult = (void *)result;
82929   return jresult;
82930 }
82931
82932
82933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82934   void * jresult ;
82935   Dali::Toolkit::Popup result;
82936
82937   {
82938     try {
82939       result = Dali::Toolkit::Popup::New();
82940     } catch (std::out_of_range& e) {
82941       {
82942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82943       };
82944     } catch (std::exception& e) {
82945       {
82946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82947       };
82948     } catch (...) {
82949       {
82950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82951       };
82952     }
82953   }
82954   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82955   return jresult;
82956 }
82957
82958
82959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82960   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82961
82962   arg1 = (Dali::Toolkit::Popup *)jarg1;
82963   {
82964     try {
82965       delete arg1;
82966     } catch (std::out_of_range& e) {
82967       {
82968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82969       };
82970     } catch (std::exception& e) {
82971       {
82972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82973       };
82974     } catch (...) {
82975       {
82976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82977       };
82978     }
82979   }
82980 }
82981
82982
82983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82984   void * jresult ;
82985   Dali::Toolkit::Popup *arg1 = 0 ;
82986   Dali::Toolkit::Popup *result = 0 ;
82987
82988   arg1 = (Dali::Toolkit::Popup *)jarg1;
82989   if (!arg1) {
82990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82991     return 0;
82992   }
82993   {
82994     try {
82995       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82996     } catch (std::out_of_range& e) {
82997       {
82998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82999       };
83000     } catch (std::exception& e) {
83001       {
83002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83003       };
83004     } catch (...) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83007       };
83008     }
83009   }
83010   jresult = (void *)result;
83011   return jresult;
83012 }
83013
83014
83015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83016   void * jresult ;
83017   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83018   Dali::Toolkit::Popup *arg2 = 0 ;
83019   Dali::Toolkit::Popup *result = 0 ;
83020
83021   arg1 = (Dali::Toolkit::Popup *)jarg1;
83022   arg2 = (Dali::Toolkit::Popup *)jarg2;
83023   if (!arg2) {
83024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83025     return 0;
83026   }
83027   {
83028     try {
83029       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83030     } catch (std::out_of_range& e) {
83031       {
83032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83033       };
83034     } catch (std::exception& e) {
83035       {
83036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83037       };
83038     } catch (...) {
83039       {
83040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83041       };
83042     }
83043   }
83044   jresult = (void *)result;
83045   return jresult;
83046 }
83047
83048
83049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83050   void * jresult ;
83051   Dali::BaseHandle arg1 ;
83052   Dali::BaseHandle *argp1 ;
83053   Dali::Toolkit::Popup result;
83054
83055   argp1 = (Dali::BaseHandle *)jarg1;
83056   if (!argp1) {
83057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83058     return 0;
83059   }
83060   arg1 = *argp1;
83061   {
83062     try {
83063       result = Dali::Toolkit::Popup::DownCast(arg1);
83064     } catch (std::out_of_range& e) {
83065       {
83066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83067       };
83068     } catch (std::exception& e) {
83069       {
83070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83075       };
83076     }
83077   }
83078   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83084   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83085   Dali::Actor arg2 ;
83086   Dali::Actor *argp2 ;
83087
83088   arg1 = (Dali::Toolkit::Popup *)jarg1;
83089   argp2 = (Dali::Actor *)jarg2;
83090   if (!argp2) {
83091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83092     return ;
83093   }
83094   arg2 = *argp2;
83095   {
83096     try {
83097       (arg1)->SetTitle(arg2);
83098     } catch (std::out_of_range& e) {
83099       {
83100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83101       };
83102     } catch (std::exception& e) {
83103       {
83104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83105       };
83106     } catch (...) {
83107       {
83108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83109       };
83110     }
83111   }
83112 }
83113
83114
83115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83116   void * jresult ;
83117   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83118   Dali::Actor result;
83119
83120   arg1 = (Dali::Toolkit::Popup *)jarg1;
83121   {
83122     try {
83123       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83124     } catch (std::out_of_range& e) {
83125       {
83126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83127       };
83128     } catch (std::exception& e) {
83129       {
83130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83131       };
83132     } catch (...) {
83133       {
83134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83135       };
83136     }
83137   }
83138   jresult = new Dali::Actor((const Dali::Actor &)result);
83139   return jresult;
83140 }
83141
83142
83143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83144   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83145   Dali::Actor arg2 ;
83146   Dali::Actor *argp2 ;
83147
83148   arg1 = (Dali::Toolkit::Popup *)jarg1;
83149   argp2 = (Dali::Actor *)jarg2;
83150   if (!argp2) {
83151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83152     return ;
83153   }
83154   arg2 = *argp2;
83155   {
83156     try {
83157       (arg1)->SetContent(arg2);
83158     } catch (std::out_of_range& e) {
83159       {
83160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83161       };
83162     } catch (std::exception& e) {
83163       {
83164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83165       };
83166     } catch (...) {
83167       {
83168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83169       };
83170     }
83171   }
83172 }
83173
83174
83175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83176   void * jresult ;
83177   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83178   Dali::Actor result;
83179
83180   arg1 = (Dali::Toolkit::Popup *)jarg1;
83181   {
83182     try {
83183       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83184     } catch (std::out_of_range& e) {
83185       {
83186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83187       };
83188     } catch (std::exception& e) {
83189       {
83190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83191       };
83192     } catch (...) {
83193       {
83194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83195       };
83196     }
83197   }
83198   jresult = new Dali::Actor((const Dali::Actor &)result);
83199   return jresult;
83200 }
83201
83202
83203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83204   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83205   Dali::Actor arg2 ;
83206   Dali::Actor *argp2 ;
83207
83208   arg1 = (Dali::Toolkit::Popup *)jarg1;
83209   argp2 = (Dali::Actor *)jarg2;
83210   if (!argp2) {
83211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83212     return ;
83213   }
83214   arg2 = *argp2;
83215   {
83216     try {
83217       (arg1)->SetFooter(arg2);
83218     } catch (std::out_of_range& e) {
83219       {
83220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83221       };
83222     } catch (std::exception& e) {
83223       {
83224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83225       };
83226     } catch (...) {
83227       {
83228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83229       };
83230     }
83231   }
83232 }
83233
83234
83235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83236   void * jresult ;
83237   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83238   Dali::Actor result;
83239
83240   arg1 = (Dali::Toolkit::Popup *)jarg1;
83241   {
83242     try {
83243       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83244     } catch (std::out_of_range& e) {
83245       {
83246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83247       };
83248     } catch (std::exception& e) {
83249       {
83250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83251       };
83252     } catch (...) {
83253       {
83254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83255       };
83256     }
83257   }
83258   jresult = new Dali::Actor((const Dali::Actor &)result);
83259   return jresult;
83260 }
83261
83262
83263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83264   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83265   Dali::Toolkit::Popup::DisplayState arg2 ;
83266
83267   arg1 = (Dali::Toolkit::Popup *)jarg1;
83268   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83269   {
83270     try {
83271       (arg1)->SetDisplayState(arg2);
83272     } catch (std::out_of_range& e) {
83273       {
83274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83275       };
83276     } catch (std::exception& e) {
83277       {
83278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83283       };
83284     }
83285   }
83286 }
83287
83288
83289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83290   int jresult ;
83291   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83292   Dali::Toolkit::Popup::DisplayState result;
83293
83294   arg1 = (Dali::Toolkit::Popup *)jarg1;
83295   {
83296     try {
83297       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83298     } catch (std::out_of_range& e) {
83299       {
83300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83301       };
83302     } catch (std::exception& e) {
83303       {
83304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83305       };
83306     } catch (...) {
83307       {
83308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83309       };
83310     }
83311   }
83312   jresult = (int)result;
83313   return jresult;
83314 }
83315
83316
83317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83318   void * jresult ;
83319   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83320   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83321
83322   arg1 = (Dali::Toolkit::Popup *)jarg1;
83323   {
83324     try {
83325       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83326     } catch (std::out_of_range& e) {
83327       {
83328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83329       };
83330     } catch (std::exception& e) {
83331       {
83332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83333       };
83334     } catch (...) {
83335       {
83336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83337       };
83338     }
83339   }
83340   jresult = (void *)result;
83341   return jresult;
83342 }
83343
83344
83345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83346   void * jresult ;
83347   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83348   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83349
83350   arg1 = (Dali::Toolkit::Popup *)jarg1;
83351   {
83352     try {
83353       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83354     } catch (std::out_of_range& e) {
83355       {
83356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83357       };
83358     } catch (std::exception& e) {
83359       {
83360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83361       };
83362     } catch (...) {
83363       {
83364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83365       };
83366     }
83367   }
83368   jresult = (void *)result;
83369   return jresult;
83370 }
83371
83372
83373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83374   void * jresult ;
83375   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83376   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83377
83378   arg1 = (Dali::Toolkit::Popup *)jarg1;
83379   {
83380     try {
83381       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83393       };
83394     }
83395   }
83396   jresult = (void *)result;
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83402   void * jresult ;
83403   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83404   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83405
83406   arg1 = (Dali::Toolkit::Popup *)jarg1;
83407   {
83408     try {
83409       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83410     } catch (std::out_of_range& e) {
83411       {
83412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83413       };
83414     } catch (std::exception& e) {
83415       {
83416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83417       };
83418     } catch (...) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83421       };
83422     }
83423   }
83424   jresult = (void *)result;
83425   return jresult;
83426 }
83427
83428
83429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83430   void * jresult ;
83431   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83432   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83433
83434   arg1 = (Dali::Toolkit::Popup *)jarg1;
83435   {
83436     try {
83437       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83438     } catch (std::out_of_range& e) {
83439       {
83440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83441       };
83442     } catch (std::exception& e) {
83443       {
83444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83445       };
83446     } catch (...) {
83447       {
83448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83449       };
83450     }
83451   }
83452   jresult = (void *)result;
83453   return jresult;
83454 }
83455
83456
83457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83458   int jresult ;
83459   int result;
83460
83461   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83462   jresult = (int)result;
83463   return jresult;
83464 }
83465
83466
83467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83468   int jresult ;
83469   int result;
83470
83471   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83472   jresult = (int)result;
83473   return jresult;
83474 }
83475
83476
83477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83478   int jresult ;
83479   int result;
83480
83481   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83482   jresult = (int)result;
83483   return jresult;
83484 }
83485
83486
83487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83488   int jresult ;
83489   int result;
83490
83491   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83492   jresult = (int)result;
83493   return jresult;
83494 }
83495
83496
83497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83498   int jresult ;
83499   int result;
83500
83501   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83502   jresult = (int)result;
83503   return jresult;
83504 }
83505
83506
83507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83508   int jresult ;
83509   int result;
83510
83511   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83512   jresult = (int)result;
83513   return jresult;
83514 }
83515
83516
83517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83518   int jresult ;
83519   int result;
83520
83521   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83522   jresult = (int)result;
83523   return jresult;
83524 }
83525
83526
83527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83528   int jresult ;
83529   int result;
83530
83531   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83532   jresult = (int)result;
83533   return jresult;
83534 }
83535
83536
83537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83538   int jresult ;
83539   int result;
83540
83541   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83542   jresult = (int)result;
83543   return jresult;
83544 }
83545
83546
83547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83548   void * jresult ;
83549   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83550
83551   {
83552     try {
83553       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83554     } catch (std::out_of_range& e) {
83555       {
83556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83557       };
83558     } catch (std::exception& e) {
83559       {
83560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83561       };
83562     } catch (...) {
83563       {
83564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83565       };
83566     }
83567   }
83568   jresult = (void *)result;
83569   return jresult;
83570 }
83571
83572
83573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83574   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83575
83576   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83577   {
83578     try {
83579       delete arg1;
83580     } catch (std::out_of_range& e) {
83581       {
83582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83583       };
83584     } catch (std::exception& e) {
83585       {
83586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83587       };
83588     } catch (...) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83591       };
83592     }
83593   }
83594 }
83595
83596
83597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83598   void * jresult ;
83599   Dali::Toolkit::ProgressBar result;
83600
83601   {
83602     try {
83603       result = Dali::Toolkit::ProgressBar::New();
83604     } catch (std::out_of_range& e) {
83605       {
83606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83607       };
83608     } catch (std::exception& e) {
83609       {
83610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83611       };
83612     } catch (...) {
83613       {
83614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83615       };
83616     }
83617   }
83618   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83619   return jresult;
83620 }
83621
83622
83623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83624   void * jresult ;
83625   Dali::Toolkit::ProgressBar *result = 0 ;
83626
83627   {
83628     try {
83629       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83630     } catch (std::out_of_range& e) {
83631       {
83632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83633       };
83634     } catch (std::exception& e) {
83635       {
83636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83637       };
83638     } catch (...) {
83639       {
83640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83641       };
83642     }
83643   }
83644   jresult = (void *)result;
83645   return jresult;
83646 }
83647
83648
83649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83650   void * jresult ;
83651   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83652   Dali::Toolkit::ProgressBar *result = 0 ;
83653
83654   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83655   if (!arg1) {
83656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83657     return 0;
83658   }
83659   {
83660     try {
83661       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83662     } catch (std::out_of_range& e) {
83663       {
83664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83665       };
83666     } catch (std::exception& e) {
83667       {
83668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83669       };
83670     } catch (...) {
83671       {
83672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83673       };
83674     }
83675   }
83676   jresult = (void *)result;
83677   return jresult;
83678 }
83679
83680
83681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83682   void * jresult ;
83683   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83684   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83685   Dali::Toolkit::ProgressBar *result = 0 ;
83686
83687   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83688   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83689   if (!arg2) {
83690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83691     return 0;
83692   }
83693   {
83694     try {
83695       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83696     } catch (std::out_of_range& e) {
83697       {
83698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83699       };
83700     } catch (std::exception& e) {
83701       {
83702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83703       };
83704     } catch (...) {
83705       {
83706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83707       };
83708     }
83709   }
83710   jresult = (void *)result;
83711   return jresult;
83712 }
83713
83714
83715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83716   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83717
83718   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83719   {
83720     try {
83721       delete arg1;
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83729       };
83730     } catch (...) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83733       };
83734     }
83735   }
83736 }
83737
83738
83739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83740   void * jresult ;
83741   Dali::BaseHandle arg1 ;
83742   Dali::BaseHandle *argp1 ;
83743   Dali::Toolkit::ProgressBar result;
83744
83745   argp1 = (Dali::BaseHandle *)jarg1;
83746   if (!argp1) {
83747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83748     return 0;
83749   }
83750   arg1 = *argp1;
83751   {
83752     try {
83753       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83754     } catch (std::out_of_range& e) {
83755       {
83756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83757       };
83758     } catch (std::exception& e) {
83759       {
83760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83761       };
83762     } catch (...) {
83763       {
83764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83765       };
83766     }
83767   }
83768   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83769   return jresult;
83770 }
83771
83772
83773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83774   void * jresult ;
83775   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83776   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83777
83778   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83779   {
83780     try {
83781       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83782     } catch (std::out_of_range& e) {
83783       {
83784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83785       };
83786     } catch (std::exception& e) {
83787       {
83788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83789       };
83790     } catch (...) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83793       };
83794     }
83795   }
83796   jresult = (void *)result;
83797   return jresult;
83798 }
83799
83800
83801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83802   void * jresult ;
83803   Dali::Toolkit::GaussianBlurView *result = 0 ;
83804
83805   {
83806     try {
83807       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83808     } catch (std::out_of_range& e) {
83809       {
83810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83811       };
83812     } catch (std::exception& e) {
83813       {
83814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83819       };
83820     }
83821   }
83822   jresult = (void *)result;
83823   return jresult;
83824 }
83825
83826
83827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83828   void * jresult ;
83829   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83830   Dali::Toolkit::GaussianBlurView *result = 0 ;
83831
83832   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83833   if (!arg1) {
83834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83835     return 0;
83836   }
83837   {
83838     try {
83839       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83840     } catch (std::out_of_range& e) {
83841       {
83842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83843       };
83844     } catch (std::exception& e) {
83845       {
83846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83847       };
83848     } catch (...) {
83849       {
83850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83851       };
83852     }
83853   }
83854   jresult = (void *)result;
83855   return jresult;
83856 }
83857
83858
83859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83860   void * jresult ;
83861   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83862   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83863   Dali::Toolkit::GaussianBlurView *result = 0 ;
83864
83865   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83866   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83867   if (!arg2) {
83868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83869     return 0;
83870   }
83871   {
83872     try {
83873       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83874     } catch (std::out_of_range& e) {
83875       {
83876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83877       };
83878     } catch (std::exception& e) {
83879       {
83880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83881       };
83882     } catch (...) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83885       };
83886     }
83887   }
83888   jresult = (void *)result;
83889   return jresult;
83890 }
83891
83892
83893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83894   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83895
83896   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83897   {
83898     try {
83899       delete arg1;
83900     } catch (std::out_of_range& e) {
83901       {
83902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83903       };
83904     } catch (std::exception& e) {
83905       {
83906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83907       };
83908     } catch (...) {
83909       {
83910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83911       };
83912     }
83913   }
83914 }
83915
83916
83917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83918   void * jresult ;
83919   Dali::BaseHandle arg1 ;
83920   Dali::BaseHandle *argp1 ;
83921   Dali::Toolkit::GaussianBlurView result;
83922
83923   argp1 = (Dali::BaseHandle *)jarg1;
83924   if (!argp1) {
83925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83926     return 0;
83927   }
83928   arg1 = *argp1;
83929   {
83930     try {
83931       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83932     } catch (std::out_of_range& e) {
83933       {
83934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83935       };
83936     } catch (std::exception& e) {
83937       {
83938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83939       };
83940     } catch (...) {
83941       {
83942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83943       };
83944     }
83945   }
83946   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83947   return jresult;
83948 }
83949
83950
83951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83952   void * jresult ;
83953   Dali::Toolkit::GaussianBlurView result;
83954
83955   {
83956     try {
83957       result = Dali::Toolkit::GaussianBlurView::New();
83958     } catch (std::out_of_range& e) {
83959       {
83960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83961       };
83962     } catch (std::exception& e) {
83963       {
83964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83965       };
83966     } catch (...) {
83967       {
83968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83969       };
83970     }
83971   }
83972   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83973   return jresult;
83974 }
83975
83976
83977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83978   void * jresult ;
83979   unsigned int arg1 ;
83980   float arg2 ;
83981   Dali::Pixel::Format arg3 ;
83982   float arg4 ;
83983   float arg5 ;
83984   bool arg6 ;
83985   Dali::Toolkit::GaussianBlurView result;
83986
83987   arg1 = (unsigned int)jarg1;
83988   arg2 = (float)jarg2;
83989   arg3 = (Dali::Pixel::Format)jarg3;
83990   arg4 = (float)jarg4;
83991   arg5 = (float)jarg5;
83992   arg6 = jarg6 ? true : false;
83993   {
83994     try {
83995       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83996     } catch (std::out_of_range& e) {
83997       {
83998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83999       };
84000     } catch (std::exception& e) {
84001       {
84002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84003       };
84004     } catch (...) {
84005       {
84006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84007       };
84008     }
84009   }
84010   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84011   return jresult;
84012 }
84013
84014
84015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84016   void * jresult ;
84017   unsigned int arg1 ;
84018   float arg2 ;
84019   Dali::Pixel::Format arg3 ;
84020   float arg4 ;
84021   float arg5 ;
84022   Dali::Toolkit::GaussianBlurView result;
84023
84024   arg1 = (unsigned int)jarg1;
84025   arg2 = (float)jarg2;
84026   arg3 = (Dali::Pixel::Format)jarg3;
84027   arg4 = (float)jarg4;
84028   arg5 = (float)jarg5;
84029   {
84030     try {
84031       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84032     } catch (std::out_of_range& e) {
84033       {
84034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84035       };
84036     } catch (std::exception& e) {
84037       {
84038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84039       };
84040     } catch (...) {
84041       {
84042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84043       };
84044     }
84045   }
84046   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84047   return jresult;
84048 }
84049
84050
84051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84052   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84053   Dali::Actor arg2 ;
84054   Dali::Actor *argp2 ;
84055
84056   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84057   argp2 = (Dali::Actor *)jarg2;
84058   if (!argp2) {
84059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84060     return ;
84061   }
84062   arg2 = *argp2;
84063   {
84064     try {
84065       (arg1)->Add(arg2);
84066     } catch (std::out_of_range& e) {
84067       {
84068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84069       };
84070     } catch (std::exception& e) {
84071       {
84072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84073       };
84074     } catch (...) {
84075       {
84076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84077       };
84078     }
84079   }
84080 }
84081
84082
84083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84084   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84085   Dali::Actor arg2 ;
84086   Dali::Actor *argp2 ;
84087
84088   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84089   argp2 = (Dali::Actor *)jarg2;
84090   if (!argp2) {
84091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84092     return ;
84093   }
84094   arg2 = *argp2;
84095   {
84096     try {
84097       (arg1)->Remove(arg2);
84098     } catch (std::out_of_range& e) {
84099       {
84100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84101       };
84102     } catch (std::exception& e) {
84103       {
84104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84105       };
84106     } catch (...) {
84107       {
84108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84109       };
84110     }
84111   }
84112 }
84113
84114
84115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84116   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84117
84118   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84119   {
84120     try {
84121       (arg1)->Activate();
84122     } catch (std::out_of_range& e) {
84123       {
84124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84125       };
84126     } catch (std::exception& e) {
84127       {
84128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84129       };
84130     } catch (...) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84133       };
84134     }
84135   }
84136 }
84137
84138
84139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84140   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84141
84142   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84143   {
84144     try {
84145       (arg1)->ActivateOnce();
84146     } catch (std::out_of_range& e) {
84147       {
84148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84149       };
84150     } catch (std::exception& e) {
84151       {
84152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84153       };
84154     } catch (...) {
84155       {
84156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84157       };
84158     }
84159   }
84160 }
84161
84162
84163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84164   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84165
84166   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84167   {
84168     try {
84169       (arg1)->Deactivate();
84170     } catch (std::out_of_range& e) {
84171       {
84172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84173       };
84174     } catch (std::exception& e) {
84175       {
84176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84177       };
84178     } catch (...) {
84179       {
84180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84181       };
84182     }
84183   }
84184 }
84185
84186
84187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84188   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84189   Dali::Image arg2 ;
84190   Dali::FrameBufferImage arg3 ;
84191   Dali::Image *argp2 ;
84192   Dali::FrameBufferImage *argp3 ;
84193
84194   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84195   argp2 = (Dali::Image *)jarg2;
84196   if (!argp2) {
84197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84198     return ;
84199   }
84200   arg2 = *argp2;
84201   argp3 = (Dali::FrameBufferImage *)jarg3;
84202   if (!argp3) {
84203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84204     return ;
84205   }
84206   arg3 = *argp3;
84207   {
84208     try {
84209       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84210     } catch (std::out_of_range& e) {
84211       {
84212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84213       };
84214     } catch (std::exception& e) {
84215       {
84216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84217       };
84218     } catch (...) {
84219       {
84220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84221       };
84222     }
84223   }
84224 }
84225
84226
84227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84228   int jresult ;
84229   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84230   Dali::Property::Index result;
84231
84232   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84233   {
84234     try {
84235       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84236     } catch (std::out_of_range& e) {
84237       {
84238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84239       };
84240     } catch (std::exception& e) {
84241       {
84242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84243       };
84244     } catch (...) {
84245       {
84246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84247       };
84248     }
84249   }
84250   jresult = result;
84251   return jresult;
84252 }
84253
84254
84255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84256   void * jresult ;
84257   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84258   Dali::FrameBufferImage result;
84259
84260   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84261   {
84262     try {
84263       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84264     } catch (std::out_of_range& e) {
84265       {
84266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84267       };
84268     } catch (std::exception& e) {
84269       {
84270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84271       };
84272     } catch (...) {
84273       {
84274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84275       };
84276     }
84277   }
84278   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84279   return jresult;
84280 }
84281
84282
84283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84284   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84285   Dali::Vector4 *arg2 = 0 ;
84286
84287   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84288   arg2 = (Dali::Vector4 *)jarg2;
84289   if (!arg2) {
84290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84291     return ;
84292   }
84293   {
84294     try {
84295       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84296     } catch (std::out_of_range& e) {
84297       {
84298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84299       };
84300     } catch (std::exception& e) {
84301       {
84302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84303       };
84304     } catch (...) {
84305       {
84306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84307       };
84308     }
84309   }
84310 }
84311
84312
84313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84314   void * jresult ;
84315   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84316   Dali::Vector4 result;
84317
84318   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84319   {
84320     try {
84321       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84322     } catch (std::out_of_range& e) {
84323       {
84324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (std::exception& e) {
84327       {
84328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84329       };
84330     } catch (...) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84333       };
84334     }
84335   }
84336   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84337   return jresult;
84338 }
84339
84340
84341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84342   void * jresult ;
84343   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84344   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84345
84346   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84347   {
84348     try {
84349       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84350     } catch (std::out_of_range& e) {
84351       {
84352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84353       };
84354     } catch (std::exception& e) {
84355       {
84356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84357       };
84358     } catch (...) {
84359       {
84360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84361       };
84362     }
84363   }
84364   jresult = (void *)result;
84365   return jresult;
84366 }
84367
84368
84369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84370   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84371
84372   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84373   {
84374     try {
84375       delete arg1;
84376     } catch (std::out_of_range& e) {
84377       {
84378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84379       };
84380     } catch (std::exception& e) {
84381       {
84382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84383       };
84384     } catch (...) {
84385       {
84386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84387       };
84388     }
84389   }
84390 }
84391
84392
84393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84394   unsigned int jresult ;
84395   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84396   unsigned int result;
84397
84398   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84399   {
84400     try {
84401       result = (unsigned int)(arg1)->GetNumberOfPages();
84402     } catch (std::out_of_range& e) {
84403       {
84404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (std::exception& e) {
84407       {
84408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (...) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84413       };
84414     }
84415   }
84416   jresult = result;
84417   return jresult;
84418 }
84419
84420
84421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84422   void * jresult ;
84423   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84424   unsigned int arg2 ;
84425   Dali::Texture result;
84426
84427   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84428   arg2 = (unsigned int)jarg2;
84429   {
84430     try {
84431       result = (arg1)->NewPage(arg2);
84432     } catch (std::out_of_range& e) {
84433       {
84434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84435       };
84436     } catch (std::exception& e) {
84437       {
84438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84439       };
84440     } catch (...) {
84441       {
84442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84443       };
84444     }
84445   }
84446   jresult = new Dali::Texture((const Dali::Texture &)result);
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84452   int jresult ;
84453   int result;
84454
84455   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84456   jresult = (int)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84462   int jresult ;
84463   int result;
84464
84465   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84466   jresult = (int)result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84472   int jresult ;
84473   int result;
84474
84475   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84476   jresult = (int)result;
84477   return jresult;
84478 }
84479
84480
84481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84482   void * jresult ;
84483   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84484
84485   {
84486     try {
84487       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84488     } catch (std::out_of_range& e) {
84489       {
84490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84491       };
84492     } catch (std::exception& e) {
84493       {
84494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84495       };
84496     } catch (...) {
84497       {
84498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84499       };
84500     }
84501   }
84502   jresult = (void *)result;
84503   return jresult;
84504 }
84505
84506
84507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84508   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84509
84510   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84511   {
84512     try {
84513       delete arg1;
84514     } catch (std::out_of_range& e) {
84515       {
84516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84517       };
84518     } catch (std::exception& e) {
84519       {
84520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84521       };
84522     } catch (...) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84525       };
84526     }
84527   }
84528 }
84529
84530
84531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84532   void * jresult ;
84533   Dali::Toolkit::PageTurnView *result = 0 ;
84534
84535   {
84536     try {
84537       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84545       };
84546     } catch (...) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84549       };
84550     }
84551   }
84552   jresult = (void *)result;
84553   return jresult;
84554 }
84555
84556
84557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84558   void * jresult ;
84559   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84560   Dali::Toolkit::PageTurnView *result = 0 ;
84561
84562   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84563   if (!arg1) {
84564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84565     return 0;
84566   }
84567   {
84568     try {
84569       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84570     } catch (std::out_of_range& e) {
84571       {
84572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84573       };
84574     } catch (std::exception& e) {
84575       {
84576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84581       };
84582     }
84583   }
84584   jresult = (void *)result;
84585   return jresult;
84586 }
84587
84588
84589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84590   void * jresult ;
84591   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84592   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84593   Dali::Toolkit::PageTurnView *result = 0 ;
84594
84595   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84596   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84597   if (!arg2) {
84598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84599     return 0;
84600   }
84601   {
84602     try {
84603       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84604     } catch (std::out_of_range& e) {
84605       {
84606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84607       };
84608     } catch (std::exception& e) {
84609       {
84610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84611       };
84612     } catch (...) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84615       };
84616     }
84617   }
84618   jresult = (void *)result;
84619   return jresult;
84620 }
84621
84622
84623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84624   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84625
84626   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84627   {
84628     try {
84629       delete arg1;
84630     } catch (std::out_of_range& e) {
84631       {
84632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84633       };
84634     } catch (std::exception& e) {
84635       {
84636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84637       };
84638     } catch (...) {
84639       {
84640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84641       };
84642     }
84643   }
84644 }
84645
84646
84647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84648   void * jresult ;
84649   Dali::BaseHandle arg1 ;
84650   Dali::BaseHandle *argp1 ;
84651   Dali::Toolkit::PageTurnView result;
84652
84653   argp1 = (Dali::BaseHandle *)jarg1;
84654   if (!argp1) {
84655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84656     return 0;
84657   }
84658   arg1 = *argp1;
84659   {
84660     try {
84661       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84662     } catch (std::out_of_range& e) {
84663       {
84664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84665       };
84666     } catch (std::exception& e) {
84667       {
84668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84669       };
84670     } catch (...) {
84671       {
84672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84673       };
84674     }
84675   }
84676   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84677   return jresult;
84678 }
84679
84680
84681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84682   void * jresult ;
84683   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84684   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84685
84686   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84687   {
84688     try {
84689       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84690     } catch (std::out_of_range& e) {
84691       {
84692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84693       };
84694     } catch (std::exception& e) {
84695       {
84696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84697       };
84698     } catch (...) {
84699       {
84700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84701       };
84702     }
84703   }
84704   jresult = (void *)result;
84705   return jresult;
84706 }
84707
84708
84709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84710   void * jresult ;
84711   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84712   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84713
84714   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84715   {
84716     try {
84717       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84718     } catch (std::out_of_range& e) {
84719       {
84720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84721       };
84722     } catch (std::exception& e) {
84723       {
84724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84725       };
84726     } catch (...) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84729       };
84730     }
84731   }
84732   jresult = (void *)result;
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84738   void * jresult ;
84739   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84740   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84741
84742   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84743   {
84744     try {
84745       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84746     } catch (std::out_of_range& e) {
84747       {
84748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84749       };
84750     } catch (std::exception& e) {
84751       {
84752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84753       };
84754     } catch (...) {
84755       {
84756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84757       };
84758     }
84759   }
84760   jresult = (void *)result;
84761   return jresult;
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84766   void * jresult ;
84767   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84768   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84769
84770   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84771   {
84772     try {
84773       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84774     } catch (std::out_of_range& e) {
84775       {
84776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (std::exception& e) {
84779       {
84780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (...) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84785       };
84786     }
84787   }
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84794   void * jresult ;
84795   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84796
84797   {
84798     try {
84799       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84800     } catch (std::out_of_range& e) {
84801       {
84802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84803       };
84804     } catch (std::exception& e) {
84805       {
84806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84807       };
84808     } catch (...) {
84809       {
84810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84811       };
84812     }
84813   }
84814   jresult = (void *)result;
84815   return jresult;
84816 }
84817
84818
84819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84820   void * jresult ;
84821   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84822   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84823
84824   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84825   if (!arg1) {
84826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84827     return 0;
84828   }
84829   {
84830     try {
84831       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84832     } catch (std::out_of_range& e) {
84833       {
84834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84835       };
84836     } catch (std::exception& e) {
84837       {
84838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84839       };
84840     } catch (...) {
84841       {
84842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84843       };
84844     }
84845   }
84846   jresult = (void *)result;
84847   return jresult;
84848 }
84849
84850
84851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84852   void * jresult ;
84853   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84854   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84855   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84856
84857   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84858   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84859   if (!arg2) {
84860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84861     return 0;
84862   }
84863   {
84864     try {
84865       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84866     } catch (std::out_of_range& e) {
84867       {
84868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84869       };
84870     } catch (std::exception& e) {
84871       {
84872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84873       };
84874     } catch (...) {
84875       {
84876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84877       };
84878     }
84879   }
84880   jresult = (void *)result;
84881   return jresult;
84882 }
84883
84884
84885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84886   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84887
84888   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84889   {
84890     try {
84891       delete arg1;
84892     } catch (std::out_of_range& e) {
84893       {
84894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84895       };
84896     } catch (std::exception& e) {
84897       {
84898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84899       };
84900     } catch (...) {
84901       {
84902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84903       };
84904     }
84905   }
84906 }
84907
84908
84909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84910   void * jresult ;
84911   Dali::Toolkit::PageFactory *arg1 = 0 ;
84912   Dali::Vector2 *arg2 = 0 ;
84913   Dali::Toolkit::PageTurnLandscapeView result;
84914
84915   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84916   if (!arg1) {
84917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84918     return 0;
84919   }
84920   arg2 = (Dali::Vector2 *)jarg2;
84921   if (!arg2) {
84922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84923     return 0;
84924   }
84925   {
84926     try {
84927       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84928     } catch (std::out_of_range& e) {
84929       {
84930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84931       };
84932     } catch (std::exception& e) {
84933       {
84934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84935       };
84936     } catch (...) {
84937       {
84938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84939       };
84940     }
84941   }
84942   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84943   return jresult;
84944 }
84945
84946
84947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84948   void * jresult ;
84949   Dali::BaseHandle arg1 ;
84950   Dali::BaseHandle *argp1 ;
84951   Dali::Toolkit::PageTurnLandscapeView result;
84952
84953   argp1 = (Dali::BaseHandle *)jarg1;
84954   if (!argp1) {
84955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84956     return 0;
84957   }
84958   arg1 = *argp1;
84959   {
84960     try {
84961       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84962     } catch (std::out_of_range& e) {
84963       {
84964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84965       };
84966     } catch (std::exception& e) {
84967       {
84968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84969       };
84970     } catch (...) {
84971       {
84972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84973       };
84974     }
84975   }
84976   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84977   return jresult;
84978 }
84979
84980
84981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84982   void * jresult ;
84983   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84984
84985   {
84986     try {
84987       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84988     } catch (std::out_of_range& e) {
84989       {
84990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (std::exception& e) {
84993       {
84994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84995       };
84996     } catch (...) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84999       };
85000     }
85001   }
85002   jresult = (void *)result;
85003   return jresult;
85004 }
85005
85006
85007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85008   void * jresult ;
85009   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85010   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85011
85012   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85013   if (!arg1) {
85014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85015     return 0;
85016   }
85017   {
85018     try {
85019       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85020     } catch (std::out_of_range& e) {
85021       {
85022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85023       };
85024     } catch (std::exception& e) {
85025       {
85026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85027       };
85028     } catch (...) {
85029       {
85030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85031       };
85032     }
85033   }
85034   jresult = (void *)result;
85035   return jresult;
85036 }
85037
85038
85039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85040   void * jresult ;
85041   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85042   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85043   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85044
85045   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85046   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85047   if (!arg2) {
85048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85049     return 0;
85050   }
85051   {
85052     try {
85053       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85054     } catch (std::out_of_range& e) {
85055       {
85056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85057       };
85058     } catch (std::exception& e) {
85059       {
85060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85061       };
85062     } catch (...) {
85063       {
85064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85065       };
85066     }
85067   }
85068   jresult = (void *)result;
85069   return jresult;
85070 }
85071
85072
85073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85074   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85075
85076   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85077   {
85078     try {
85079       delete arg1;
85080     } catch (std::out_of_range& e) {
85081       {
85082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85083       };
85084     } catch (std::exception& e) {
85085       {
85086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85087       };
85088     } catch (...) {
85089       {
85090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85091       };
85092     }
85093   }
85094 }
85095
85096
85097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85098   void * jresult ;
85099   Dali::Toolkit::PageFactory *arg1 = 0 ;
85100   Dali::Vector2 *arg2 = 0 ;
85101   Dali::Toolkit::PageTurnPortraitView result;
85102
85103   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85104   if (!arg1) {
85105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85106     return 0;
85107   }
85108   arg2 = (Dali::Vector2 *)jarg2;
85109   if (!arg2) {
85110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85111     return 0;
85112   }
85113   {
85114     try {
85115       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85116     } catch (std::out_of_range& e) {
85117       {
85118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (std::exception& e) {
85121       {
85122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85123       };
85124     } catch (...) {
85125       {
85126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85127       };
85128     }
85129   }
85130   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85131   return jresult;
85132 }
85133
85134
85135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85136   void * jresult ;
85137   Dali::BaseHandle arg1 ;
85138   Dali::BaseHandle *argp1 ;
85139   Dali::Toolkit::PageTurnPortraitView result;
85140
85141   argp1 = (Dali::BaseHandle *)jarg1;
85142   if (!argp1) {
85143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85144     return 0;
85145   }
85146   arg1 = *argp1;
85147   {
85148     try {
85149       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85150     } catch (std::out_of_range& e) {
85151       {
85152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85153       };
85154     } catch (std::exception& e) {
85155       {
85156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85157       };
85158     } catch (...) {
85159       {
85160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85161       };
85162     }
85163   }
85164   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85165   return jresult;
85166 }
85167
85168
85169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85170   int jresult ;
85171   int result;
85172
85173   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85174   jresult = (int)result;
85175   return jresult;
85176 }
85177
85178
85179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85180   int jresult ;
85181   int result;
85182
85183   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85184   jresult = (int)result;
85185   return jresult;
85186 }
85187
85188
85189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85190   int jresult ;
85191   int result;
85192
85193   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85194   jresult = (int)result;
85195   return jresult;
85196 }
85197
85198
85199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85200   void * jresult ;
85201   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85202
85203   {
85204     try {
85205       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85206     } catch (std::out_of_range& e) {
85207       {
85208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (std::exception& e) {
85211       {
85212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (...) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85217       };
85218     }
85219   }
85220   jresult = (void *)result;
85221   return jresult;
85222 }
85223
85224
85225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85226   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85227
85228   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85229   {
85230     try {
85231       delete arg1;
85232     } catch (std::out_of_range& e) {
85233       {
85234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85235       };
85236     } catch (std::exception& e) {
85237       {
85238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85239       };
85240     } catch (...) {
85241       {
85242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85243       };
85244     }
85245   }
85246 }
85247
85248
85249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85250   void * jresult ;
85251   Dali::Toolkit::ToggleButton *result = 0 ;
85252
85253   {
85254     try {
85255       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85256     } catch (std::out_of_range& e) {
85257       {
85258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85259       };
85260     } catch (std::exception& e) {
85261       {
85262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85263       };
85264     } catch (...) {
85265       {
85266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85267       };
85268     }
85269   }
85270   jresult = (void *)result;
85271   return jresult;
85272 }
85273
85274
85275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85276   void * jresult ;
85277   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85278   Dali::Toolkit::ToggleButton *result = 0 ;
85279
85280   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85281   if (!arg1) {
85282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85283     return 0;
85284   }
85285   {
85286     try {
85287       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85288     } catch (std::out_of_range& e) {
85289       {
85290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85291       };
85292     } catch (std::exception& e) {
85293       {
85294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85295       };
85296     } catch (...) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85299       };
85300     }
85301   }
85302   jresult = (void *)result;
85303   return jresult;
85304 }
85305
85306
85307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85308   void * jresult ;
85309   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85310   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85311   Dali::Toolkit::ToggleButton *result = 0 ;
85312
85313   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85314   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85315   if (!arg2) {
85316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85317     return 0;
85318   }
85319   {
85320     try {
85321       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85322     } catch (std::out_of_range& e) {
85323       {
85324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85325       };
85326     } catch (std::exception& e) {
85327       {
85328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85329       };
85330     } catch (...) {
85331       {
85332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85333       };
85334     }
85335   }
85336   jresult = (void *)result;
85337   return jresult;
85338 }
85339
85340
85341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85342   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85343
85344   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85345   {
85346     try {
85347       delete arg1;
85348     } catch (std::out_of_range& e) {
85349       {
85350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85351       };
85352     } catch (std::exception& e) {
85353       {
85354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85355       };
85356     } catch (...) {
85357       {
85358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85359       };
85360     }
85361   }
85362 }
85363
85364
85365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85366   void * jresult ;
85367   Dali::Toolkit::ToggleButton result;
85368
85369   {
85370     try {
85371       result = Dali::Toolkit::ToggleButton::New();
85372     } catch (std::out_of_range& e) {
85373       {
85374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85375       };
85376     } catch (std::exception& e) {
85377       {
85378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (...) {
85381       {
85382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85383       };
85384     }
85385   }
85386   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85387   return jresult;
85388 }
85389
85390
85391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85392   void * jresult ;
85393   Dali::BaseHandle arg1 ;
85394   Dali::BaseHandle *argp1 ;
85395   Dali::Toolkit::ToggleButton result;
85396
85397   argp1 = (Dali::BaseHandle *)jarg1;
85398   if (!argp1) {
85399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85400     return 0;
85401   }
85402   arg1 = *argp1;
85403   {
85404     try {
85405       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85406     } catch (std::out_of_range& e) {
85407       {
85408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (std::exception& e) {
85411       {
85412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85413       };
85414     } catch (...) {
85415       {
85416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85417       };
85418     }
85419   }
85420   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85421   return jresult;
85422 }
85423
85424
85425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85426   void * jresult ;
85427   Dali::Toolkit::Visual::Base *result = 0 ;
85428
85429   {
85430     try {
85431       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85432     } catch (std::out_of_range& e) {
85433       {
85434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (std::exception& e) {
85437       {
85438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85439       };
85440     } catch (...) {
85441       {
85442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85443       };
85444     }
85445   }
85446   jresult = (void *)result;
85447   return jresult;
85448 }
85449
85450
85451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85452   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85453
85454   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85455   {
85456     try {
85457       delete arg1;
85458     } catch (std::out_of_range& e) {
85459       {
85460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85461       };
85462     } catch (std::exception& e) {
85463       {
85464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85465       };
85466     } catch (...) {
85467       {
85468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85469       };
85470     }
85471   }
85472 }
85473
85474
85475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85476   void * jresult ;
85477   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85478   Dali::Toolkit::Visual::Base *result = 0 ;
85479
85480   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85481   if (!arg1) {
85482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85483     return 0;
85484   }
85485   {
85486     try {
85487       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85488     } catch (std::out_of_range& e) {
85489       {
85490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85491       };
85492     } catch (std::exception& e) {
85493       {
85494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85495       };
85496     } catch (...) {
85497       {
85498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85499       };
85500     }
85501   }
85502   jresult = (void *)result;
85503   return jresult;
85504 }
85505
85506
85507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85508   void * jresult ;
85509   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85510   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85511   Dali::Toolkit::Visual::Base *result = 0 ;
85512
85513   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85514   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85515   if (!arg2) {
85516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85517     return 0;
85518   }
85519   {
85520     try {
85521       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85522     } catch (std::out_of_range& e) {
85523       {
85524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85525       };
85526     } catch (std::exception& e) {
85527       {
85528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85529       };
85530     } catch (...) {
85531       {
85532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85533       };
85534     }
85535   }
85536   jresult = (void *)result;
85537   return jresult;
85538 }
85539
85540
85541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85542   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85543   std::string *arg2 = 0 ;
85544
85545   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85546   if (!jarg2) {
85547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85548     return ;
85549   }
85550   std::string arg2_str(jarg2);
85551   arg2 = &arg2_str;
85552   {
85553     try {
85554       (arg1)->SetName((std::string const &)*arg2);
85555     } catch (std::out_of_range& e) {
85556       {
85557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85558       };
85559     } catch (std::exception& e) {
85560       {
85561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85562       };
85563     } catch (...) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85566       };
85567     }
85568   }
85569
85570   //argout typemap for const std::string&
85571
85572 }
85573
85574
85575 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85576   char * jresult ;
85577   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85578   std::string *result = 0 ;
85579
85580   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85581   {
85582     try {
85583       result = (std::string *) &(arg1)->GetName();
85584     } catch (std::out_of_range& e) {
85585       {
85586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (std::exception& e) {
85589       {
85590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (...) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85595       };
85596     }
85597   }
85598   jresult = SWIG_csharp_string_callback(result->c_str());
85599   return jresult;
85600 }
85601
85602
85603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85604   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85605   Dali::Property::Map *arg2 = 0 ;
85606   Dali::Size arg3 ;
85607   Dali::Size *argp3 ;
85608
85609   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85610   arg2 = (Dali::Property::Map *)jarg2;
85611   if (!arg2) {
85612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85613     return ;
85614   }
85615   argp3 = (Dali::Size *)jarg3;
85616   if (!argp3) {
85617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85618     return ;
85619   }
85620   arg3 = *argp3;
85621   {
85622     try {
85623       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85624     } catch (std::out_of_range& e) {
85625       {
85626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85627       };
85628     } catch (std::exception& e) {
85629       {
85630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85631       };
85632     } catch (...) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85635       };
85636     }
85637   }
85638 }
85639
85640
85641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85642   float jresult ;
85643   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85644   float arg2 ;
85645   float result;
85646
85647   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85648   arg2 = (float)jarg2;
85649   {
85650     try {
85651       result = (float)(arg1)->GetHeightForWidth(arg2);
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (...) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85663       };
85664     }
85665   }
85666   jresult = result;
85667   return jresult;
85668 }
85669
85670
85671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85672   float jresult ;
85673   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85674   float arg2 ;
85675   float result;
85676
85677   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85678   arg2 = (float)jarg2;
85679   {
85680     try {
85681       result = (float)(arg1)->GetWidthForHeight(arg2);
85682     } catch (std::out_of_range& e) {
85683       {
85684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85685       };
85686     } catch (std::exception& e) {
85687       {
85688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85689       };
85690     } catch (...) {
85691       {
85692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85693       };
85694     }
85695   }
85696   jresult = result;
85697   return jresult;
85698 }
85699
85700
85701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85702   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85703   Dali::Vector2 *arg2 = 0 ;
85704
85705   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85706   arg2 = (Dali::Vector2 *)jarg2;
85707   if (!arg2) {
85708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85709     return ;
85710   }
85711   {
85712     try {
85713       (arg1)->GetNaturalSize(*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_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85732   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85733   float arg2 ;
85734
85735   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85736   arg2 = (float)jarg2;
85737   {
85738     try {
85739       (arg1)->SetDepthIndex(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 float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85758   float jresult ;
85759   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85760   float result;
85761
85762   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85763   {
85764     try {
85765       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85766     } catch (std::out_of_range& e) {
85767       {
85768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85769       };
85770     } catch (std::exception& e) {
85771       {
85772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (...) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85777       };
85778     }
85779   }
85780   jresult = result;
85781   return jresult;
85782 }
85783
85784
85785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85786   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85787   Dali::Property::Map *arg2 = 0 ;
85788
85789   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85790   arg2 = (Dali::Property::Map *)jarg2;
85791   if (!arg2) {
85792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85793     return ;
85794   }
85795   {
85796     try {
85797       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85798     } catch (std::out_of_range& e) {
85799       {
85800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85801       };
85802     } catch (std::exception& e) {
85803       {
85804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85805       };
85806     } catch (...) {
85807       {
85808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85809       };
85810     }
85811   }
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85816   void * jresult ;
85817   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85818   Dali::Toolkit::Visual::Base *result = 0 ;
85819
85820   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85821   {
85822     try {
85823       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85824     } catch (std::out_of_range& e) {
85825       {
85826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (std::exception& e) {
85829       {
85830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85831       };
85832     } catch (...) {
85833       {
85834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85835       };
85836     }
85837   }
85838   jresult = (void *)result;
85839   return jresult;
85840 }
85841
85842
85843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85844   void * jresult ;
85845   Dali::Toolkit::VisualFactory result;
85846
85847   {
85848     try {
85849       result = Dali::Toolkit::VisualFactory::Get();
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85861       };
85862     }
85863   }
85864   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85865   return jresult;
85866 }
85867
85868
85869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85870   void * jresult ;
85871   Dali::Toolkit::VisualFactory *result = 0 ;
85872
85873   {
85874     try {
85875       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85876     } catch (std::out_of_range& e) {
85877       {
85878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85879       };
85880     } catch (std::exception& e) {
85881       {
85882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (...) {
85885       {
85886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85887       };
85888     }
85889   }
85890   jresult = (void *)result;
85891   return jresult;
85892 }
85893
85894
85895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85896   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85897
85898   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85899   {
85900     try {
85901       delete arg1;
85902     } catch (std::out_of_range& e) {
85903       {
85904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85905       };
85906     } catch (std::exception& e) {
85907       {
85908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85909       };
85910     } catch (...) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85913       };
85914     }
85915   }
85916 }
85917
85918
85919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85920   void * jresult ;
85921   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85922   Dali::Toolkit::VisualFactory *result = 0 ;
85923
85924   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85925   if (!arg1) {
85926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85927     return 0;
85928   }
85929   {
85930     try {
85931       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (...) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85943       };
85944     }
85945   }
85946   jresult = (void *)result;
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85952   void * jresult ;
85953   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85954   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85955   Dali::Toolkit::VisualFactory *result = 0 ;
85956
85957   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85958   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85959   if (!arg2) {
85960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85961     return 0;
85962   }
85963   {
85964     try {
85965       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85973       };
85974     } catch (...) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85977       };
85978     }
85979   }
85980   jresult = (void *)result;
85981   return jresult;
85982 }
85983
85984
85985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85986   void * jresult ;
85987   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85988   Dali::Property::Map *arg2 = 0 ;
85989   Dali::Toolkit::Visual::Base result;
85990
85991   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85992   arg2 = (Dali::Property::Map *)jarg2;
85993   if (!arg2) {
85994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85995     return 0;
85996   }
85997   {
85998     try {
85999       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86000     } catch (std::out_of_range& e) {
86001       {
86002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86003       };
86004     } catch (std::exception& e) {
86005       {
86006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (...) {
86009       {
86010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86011       };
86012     }
86013   }
86014   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86015   return jresult;
86016 }
86017
86018
86019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
86020   void * jresult ;
86021   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86022   Dali::Image *arg2 = 0 ;
86023   Dali::Toolkit::Visual::Base result;
86024
86025   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86026   arg2 = (Dali::Image *)jarg2;
86027   if (!arg2) {
86028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
86029     return 0;
86030   }
86031   {
86032     try {
86033       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
86034     } catch (std::out_of_range& e) {
86035       {
86036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (std::exception& e) {
86039       {
86040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86049   return jresult;
86050 }
86051
86052
86053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86054   void * jresult ;
86055   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86056   std::string *arg2 = 0 ;
86057   Dali::ImageDimensions arg3 ;
86058   Dali::ImageDimensions *argp3 ;
86059   Dali::Toolkit::Visual::Base result;
86060
86061   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86062   if (!jarg2) {
86063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86064     return 0;
86065   }
86066   std::string arg2_str(jarg2);
86067   arg2 = &arg2_str;
86068   argp3 = (Dali::ImageDimensions *)jarg3;
86069   if (!argp3) {
86070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86071     return 0;
86072   }
86073   arg3 = *argp3;
86074   {
86075     try {
86076       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86077     } catch (std::out_of_range& e) {
86078       {
86079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86080       };
86081     } catch (std::exception& e) {
86082       {
86083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86084       };
86085     } catch (...) {
86086       {
86087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86088       };
86089     }
86090   }
86091   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86092
86093   //argout typemap for const std::string&
86094
86095   return jresult;
86096 }
86097
86098
86099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86100   void * jresult ;
86101   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86102
86103   {
86104     try {
86105       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86106     } catch (std::out_of_range& e) {
86107       {
86108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86109       };
86110     } catch (std::exception& e) {
86111       {
86112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86113       };
86114     } catch (...) {
86115       {
86116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86117       };
86118     }
86119   }
86120   jresult = (void *)result;
86121   return jresult;
86122 }
86123
86124
86125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86126   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86127
86128   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86129   {
86130     try {
86131       delete arg1;
86132     } catch (std::out_of_range& e) {
86133       {
86134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86135       };
86136     } catch (std::exception& e) {
86137       {
86138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86139       };
86140     } catch (...) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86143       };
86144     }
86145   }
86146 }
86147
86148
86149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86150   void * jresult ;
86151   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86152   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86153
86154   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86155   if (!arg1) {
86156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86157     return 0;
86158   }
86159   {
86160     try {
86161       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
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 void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86182   void * jresult ;
86183   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86184   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86185   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86186
86187   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86188   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86189   if (!arg2) {
86190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86191     return 0;
86192   }
86193   {
86194     try {
86195       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86196     } catch (std::out_of_range& e) {
86197       {
86198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86199       };
86200     } catch (std::exception& e) {
86201       {
86202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86203       };
86204     } catch (...) {
86205       {
86206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86207       };
86208     }
86209   }
86210   jresult = (void *)result;
86211   return jresult;
86212 }
86213
86214
86215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86216   void * jresult ;
86217   Dali::Toolkit::AsyncImageLoader result;
86218
86219   {
86220     try {
86221       result = Dali::Toolkit::AsyncImageLoader::New();
86222     } catch (std::out_of_range& e) {
86223       {
86224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (std::exception& e) {
86227       {
86228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (...) {
86231       {
86232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86233       };
86234     }
86235   }
86236   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86237   return jresult;
86238 }
86239
86240
86241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86242   void * jresult ;
86243   Dali::BaseHandle arg1 ;
86244   Dali::BaseHandle *argp1 ;
86245   Dali::Toolkit::AsyncImageLoader result;
86246
86247   argp1 = (Dali::BaseHandle *)jarg1;
86248   if (!argp1) {
86249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86250     return 0;
86251   }
86252   arg1 = *argp1;
86253   {
86254     try {
86255       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86256     } catch (std::out_of_range& e) {
86257       {
86258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (std::exception& e) {
86261       {
86262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86263       };
86264     } catch (...) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86267       };
86268     }
86269   }
86270   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86271   return jresult;
86272 }
86273
86274
86275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86276   unsigned int jresult ;
86277   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86278   std::string *arg2 = 0 ;
86279   uint32_t result;
86280
86281   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86282   if (!jarg2) {
86283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86284     return 0;
86285   }
86286   std::string arg2_str(jarg2);
86287   arg2 = &arg2_str;
86288   {
86289     try {
86290       result = (arg1)->Load((std::string const &)*arg2);
86291     } catch (std::out_of_range& e) {
86292       {
86293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86294       };
86295     } catch (std::exception& e) {
86296       {
86297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (...) {
86300       {
86301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86302       };
86303     }
86304   }
86305   jresult = result;
86306
86307   //argout typemap for const std::string&
86308
86309   return jresult;
86310 }
86311
86312
86313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86314   unsigned int jresult ;
86315   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86316   std::string *arg2 = 0 ;
86317   Dali::ImageDimensions arg3 ;
86318   Dali::ImageDimensions *argp3 ;
86319   uint32_t result;
86320
86321   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86322   if (!jarg2) {
86323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86324     return 0;
86325   }
86326   std::string arg2_str(jarg2);
86327   arg2 = &arg2_str;
86328   argp3 = (Dali::ImageDimensions *)jarg3;
86329   if (!argp3) {
86330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86331     return 0;
86332   }
86333   arg3 = *argp3;
86334   {
86335     try {
86336       result = (arg1)->Load((std::string const &)*arg2,arg3);
86337     } catch (std::out_of_range& e) {
86338       {
86339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86340       };
86341     } catch (std::exception& e) {
86342       {
86343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86344       };
86345     } catch (...) {
86346       {
86347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86348       };
86349     }
86350   }
86351   jresult = result;
86352
86353   //argout typemap for const std::string&
86354
86355   return jresult;
86356 }
86357
86358
86359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86360   unsigned int jresult ;
86361   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86362   std::string *arg2 = 0 ;
86363   Dali::ImageDimensions arg3 ;
86364   Dali::FittingMode::Type arg4 ;
86365   Dali::SamplingMode::Type arg5 ;
86366   bool arg6 ;
86367   Dali::ImageDimensions *argp3 ;
86368   uint32_t result;
86369
86370   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86371   if (!jarg2) {
86372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86373     return 0;
86374   }
86375   std::string arg2_str(jarg2);
86376   arg2 = &arg2_str;
86377   argp3 = (Dali::ImageDimensions *)jarg3;
86378   if (!argp3) {
86379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86380     return 0;
86381   }
86382   arg3 = *argp3;
86383   arg4 = (Dali::FittingMode::Type)jarg4;
86384   arg5 = (Dali::SamplingMode::Type)jarg5;
86385   arg6 = jarg6 ? true : false;
86386   {
86387     try {
86388       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86389     } catch (std::out_of_range& e) {
86390       {
86391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86392       };
86393     } catch (std::exception& e) {
86394       {
86395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86400       };
86401     }
86402   }
86403   jresult = result;
86404
86405   //argout typemap for const std::string&
86406
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86412   unsigned int jresult ;
86413   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86414   uint32_t arg2 ;
86415   bool result;
86416
86417   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86418   arg2 = (uint32_t)jarg2;
86419   {
86420     try {
86421       result = (bool)(arg1)->Cancel(arg2);
86422     } catch (std::out_of_range& e) {
86423       {
86424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (std::exception& e) {
86427       {
86428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (...) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86433       };
86434     }
86435   }
86436   jresult = result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86442   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86443
86444   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86445   {
86446     try {
86447       (arg1)->CancelAll();
86448     } catch (std::out_of_range& e) {
86449       {
86450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (std::exception& e) {
86453       {
86454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (...) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86459       };
86460     }
86461   }
86462 }
86463
86464
86465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86466   void * jresult ;
86467   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86468   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86469
86470   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86471   {
86472     try {
86473       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86474     } catch (std::out_of_range& e) {
86475       {
86476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86477       };
86478     } catch (std::exception& e) {
86479       {
86480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86485       };
86486     }
86487   }
86488   jresult = (void *)result;
86489   return jresult;
86490 }
86491
86492
86493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86494   void * jresult ;
86495   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86496   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86497
86498   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86499   {
86500     try {
86501       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86502     } catch (std::out_of_range& e) {
86503       {
86504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86505       };
86506     } catch (std::exception& e) {
86507       {
86508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86509       };
86510     } catch (...) {
86511       {
86512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86513       };
86514     }
86515   }
86516   jresult = (void *)result;
86517   return jresult;
86518 }
86519
86520
86521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86522   void * jresult ;
86523   std::string *arg1 = 0 ;
86524   Dali::PixelData result;
86525
86526   if (!jarg1) {
86527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86528     return 0;
86529   }
86530   std::string arg1_str(jarg1);
86531   arg1 = &arg1_str;
86532   {
86533     try {
86534       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86535     } catch (std::out_of_range& e) {
86536       {
86537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86538       };
86539     } catch (std::exception& e) {
86540       {
86541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86542       };
86543     } catch (...) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86546       };
86547     }
86548   }
86549   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86550
86551   //argout typemap for const std::string&
86552
86553   return jresult;
86554 }
86555
86556
86557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86558   void * jresult ;
86559   std::string *arg1 = 0 ;
86560   Dali::ImageDimensions arg2 ;
86561   Dali::ImageDimensions *argp2 ;
86562   Dali::PixelData result;
86563
86564   if (!jarg1) {
86565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86566     return 0;
86567   }
86568   std::string arg1_str(jarg1);
86569   arg1 = &arg1_str;
86570   argp2 = (Dali::ImageDimensions *)jarg2;
86571   if (!argp2) {
86572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86573     return 0;
86574   }
86575   arg2 = *argp2;
86576   {
86577     try {
86578       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86579     } catch (std::out_of_range& e) {
86580       {
86581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86582       };
86583     } catch (std::exception& e) {
86584       {
86585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86586       };
86587     } catch (...) {
86588       {
86589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86590       };
86591     }
86592   }
86593   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86594
86595   //argout typemap for const std::string&
86596
86597   return jresult;
86598 }
86599
86600
86601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86602   void * jresult ;
86603   std::string *arg1 = 0 ;
86604   Dali::ImageDimensions arg2 ;
86605   Dali::FittingMode::Type arg3 ;
86606   Dali::SamplingMode::Type arg4 ;
86607   bool arg5 ;
86608   Dali::ImageDimensions *argp2 ;
86609   Dali::PixelData result;
86610
86611   if (!jarg1) {
86612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86613     return 0;
86614   }
86615   std::string arg1_str(jarg1);
86616   arg1 = &arg1_str;
86617   argp2 = (Dali::ImageDimensions *)jarg2;
86618   if (!argp2) {
86619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86620     return 0;
86621   }
86622   arg2 = *argp2;
86623   arg3 = (Dali::FittingMode::Type)jarg3;
86624   arg4 = (Dali::SamplingMode::Type)jarg4;
86625   arg5 = jarg5 ? true : false;
86626   {
86627     try {
86628       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86629     } catch (std::out_of_range& e) {
86630       {
86631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86632       };
86633     } catch (std::exception& e) {
86634       {
86635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86636       };
86637     } catch (...) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86640       };
86641     }
86642   }
86643   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86644
86645   //argout typemap for const std::string&
86646
86647   return jresult;
86648 }
86649
86650
86651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86652   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86653
86654   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86655   {
86656     try {
86657       delete arg1;
86658     } catch (std::out_of_range& e) {
86659       {
86660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86661       };
86662     } catch (std::exception& e) {
86663       {
86664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86665       };
86666     } catch (...) {
86667       {
86668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86669       };
86670     }
86671   }
86672 }
86673
86674
86675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86676   void * jresult ;
86677   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86678   Dali::Actor arg2 ;
86679   Dali::Actor arg3 ;
86680   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86681   Dali::Actor *argp2 ;
86682   Dali::Actor *argp3 ;
86683   Dali::Actor result;
86684
86685   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86686   argp2 = (Dali::Actor *)jarg2;
86687   if (!argp2) {
86688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86689     return 0;
86690   }
86691   arg2 = *argp2;
86692   argp3 = (Dali::Actor *)jarg3;
86693   if (!argp3) {
86694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86695     return 0;
86696   }
86697   arg3 = *argp3;
86698   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86699   {
86700     try {
86701       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86702     } catch (std::out_of_range& e) {
86703       {
86704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86705       };
86706     } catch (std::exception& e) {
86707       {
86708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (...) {
86711       {
86712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86713       };
86714     }
86715   }
86716   jresult = new Dali::Actor((const Dali::Actor &)result);
86717   return jresult;
86718 }
86719
86720
86721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86722   void * jresult ;
86723   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86724
86725   {
86726     try {
86727       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86728     } catch (std::out_of_range& e) {
86729       {
86730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (std::exception& e) {
86733       {
86734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86735       };
86736     } catch (...) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86739       };
86740     }
86741   }
86742   jresult = (void *)result;
86743   return jresult;
86744 }
86745
86746
86747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86748   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86749   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86750   if (director) {
86751     director->swig_connect_director(callback0);
86752   }
86753 }
86754
86755
86756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86757   KeyboardFocusManager arg1 ;
86758   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86759   KeyboardFocusManager *argp1 ;
86760
86761   argp1 = (KeyboardFocusManager *)jarg1;
86762   if (!argp1) {
86763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86764     return ;
86765   }
86766   arg1 = *argp1;
86767   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86768   if (!arg2) {
86769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86770     return ;
86771   }
86772   {
86773     try {
86774       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86775     } catch (std::out_of_range& e) {
86776       {
86777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86778       };
86779     } catch (std::exception& e) {
86780       {
86781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86782       };
86783     } catch (...) {
86784       {
86785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86786       };
86787     }
86788   }
86789 }
86790
86791
86792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86793   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86794
86795   arg1 = (std::vector< unsigned int > *)jarg1;
86796   {
86797     try {
86798       (arg1)->clear();
86799     } catch (std::out_of_range& e) {
86800       {
86801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86802       };
86803     } catch (std::exception& e) {
86804       {
86805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86806       };
86807     } catch (...) {
86808       {
86809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86810       };
86811     }
86812   }
86813 }
86814
86815
86816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86817   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86818   unsigned int *arg2 = 0 ;
86819   unsigned int temp2 ;
86820
86821   arg1 = (std::vector< unsigned int > *)jarg1;
86822   temp2 = (unsigned int)jarg2;
86823   arg2 = &temp2;
86824   {
86825     try {
86826       (arg1)->push_back((unsigned int const &)*arg2);
86827     } catch (std::out_of_range& e) {
86828       {
86829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86830       };
86831     } catch (std::exception& e) {
86832       {
86833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86834       };
86835     } catch (...) {
86836       {
86837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86838       };
86839     }
86840   }
86841 }
86842
86843
86844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86845   unsigned long jresult ;
86846   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86847   std::vector< unsigned int >::size_type result;
86848
86849   arg1 = (std::vector< unsigned int > *)jarg1;
86850   {
86851     try {
86852       result = ((std::vector< unsigned int > const *)arg1)->size();
86853     } catch (std::out_of_range& e) {
86854       {
86855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86856       };
86857     } catch (std::exception& e) {
86858       {
86859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86860       };
86861     } catch (...) {
86862       {
86863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86864       };
86865     }
86866   }
86867   jresult = (unsigned long)result;
86868   return jresult;
86869 }
86870
86871
86872 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86873   unsigned long jresult ;
86874   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86875   std::vector< unsigned int >::size_type result;
86876
86877   arg1 = (std::vector< unsigned int > *)jarg1;
86878   {
86879     try {
86880       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (...) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86892       };
86893     }
86894   }
86895   jresult = (unsigned long)result;
86896   return jresult;
86897 }
86898
86899
86900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86902   std::vector< unsigned int >::size_type arg2 ;
86903
86904   arg1 = (std::vector< unsigned int > *)jarg1;
86905   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86906   {
86907     try {
86908       (arg1)->reserve(arg2);
86909     } catch (std::out_of_range& e) {
86910       {
86911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86912       };
86913     } catch (std::exception& e) {
86914       {
86915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86916       };
86917     } catch (...) {
86918       {
86919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86920       };
86921     }
86922   }
86923 }
86924
86925
86926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86927   void * jresult ;
86928   std::vector< unsigned int > *result = 0 ;
86929
86930   {
86931     try {
86932       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86933     } catch (std::out_of_range& e) {
86934       {
86935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86936       };
86937     } catch (std::exception& e) {
86938       {
86939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86940       };
86941     } catch (...) {
86942       {
86943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86944       };
86945     }
86946   }
86947   jresult = (void *)result;
86948   return jresult;
86949 }
86950
86951
86952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86953   void * jresult ;
86954   std::vector< unsigned int > *arg1 = 0 ;
86955   std::vector< unsigned int > *result = 0 ;
86956
86957   arg1 = (std::vector< unsigned int > *)jarg1;
86958   if (!arg1) {
86959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86960     return 0;
86961   }
86962   {
86963     try {
86964       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86965     } catch (std::out_of_range& e) {
86966       {
86967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (std::exception& e) {
86970       {
86971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (...) {
86974       {
86975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86976       };
86977     }
86978   }
86979   jresult = (void *)result;
86980   return jresult;
86981 }
86982
86983
86984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86985   void * jresult ;
86986   int arg1 ;
86987   std::vector< unsigned int > *result = 0 ;
86988
86989   arg1 = (int)jarg1;
86990   {
86991     try {
86992       try {
86993         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86994       }
86995       catch(std::out_of_range &_e) {
86996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86997         return 0;
86998       }
86999
87000     } catch (std::out_of_range& e) {
87001       {
87002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87003       };
87004     } catch (std::exception& e) {
87005       {
87006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87007       };
87008     } catch (...) {
87009       {
87010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87011       };
87012     }
87013   }
87014   jresult = (void *)result;
87015   return jresult;
87016 }
87017
87018
87019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87020   unsigned int jresult ;
87021   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87022   int arg2 ;
87023   unsigned int result;
87024
87025   arg1 = (std::vector< unsigned int > *)jarg1;
87026   arg2 = (int)jarg2;
87027   {
87028     try {
87029       try {
87030         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87031       }
87032       catch(std::out_of_range &_e) {
87033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87034         return 0;
87035       }
87036
87037     } catch (std::out_of_range& e) {
87038       {
87039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87040       };
87041     } catch (std::exception& e) {
87042       {
87043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87044       };
87045     } catch (...) {
87046       {
87047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87048       };
87049     }
87050   }
87051   jresult = result;
87052   return jresult;
87053 }
87054
87055
87056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87057   unsigned int jresult ;
87058   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87059   int arg2 ;
87060   unsigned int *result = 0 ;
87061
87062   arg1 = (std::vector< unsigned int > *)jarg1;
87063   arg2 = (int)jarg2;
87064   {
87065     try {
87066       try {
87067         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87068       }
87069       catch(std::out_of_range &_e) {
87070         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87071         return 0;
87072       }
87073
87074     } catch (std::out_of_range& e) {
87075       {
87076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87077       };
87078     } catch (std::exception& e) {
87079       {
87080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87081       };
87082     } catch (...) {
87083       {
87084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87085       };
87086     }
87087   }
87088   jresult = *result;
87089   return jresult;
87090 }
87091
87092
87093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87094   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87095   int arg2 ;
87096   unsigned int *arg3 = 0 ;
87097   unsigned int temp3 ;
87098
87099   arg1 = (std::vector< unsigned int > *)jarg1;
87100   arg2 = (int)jarg2;
87101   temp3 = (unsigned int)jarg3;
87102   arg3 = &temp3;
87103   {
87104     try {
87105       try {
87106         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87107       }
87108       catch(std::out_of_range &_e) {
87109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87110         return ;
87111       }
87112
87113     } catch (std::out_of_range& e) {
87114       {
87115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87116       };
87117     } catch (std::exception& e) {
87118       {
87119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87120       };
87121     } catch (...) {
87122       {
87123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87124       };
87125     }
87126   }
87127 }
87128
87129
87130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87131   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87132   std::vector< unsigned int > *arg2 = 0 ;
87133
87134   arg1 = (std::vector< unsigned int > *)jarg1;
87135   arg2 = (std::vector< unsigned int > *)jarg2;
87136   if (!arg2) {
87137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87138     return ;
87139   }
87140   {
87141     try {
87142       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87143     } catch (std::out_of_range& e) {
87144       {
87145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87146       };
87147     } catch (std::exception& e) {
87148       {
87149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87150       };
87151     } catch (...) {
87152       {
87153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87154       };
87155     }
87156   }
87157 }
87158
87159
87160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87161   void * jresult ;
87162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87163   int arg2 ;
87164   int arg3 ;
87165   std::vector< unsigned int > *result = 0 ;
87166
87167   arg1 = (std::vector< unsigned int > *)jarg1;
87168   arg2 = (int)jarg2;
87169   arg3 = (int)jarg3;
87170   {
87171     try {
87172       try {
87173         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87174       }
87175       catch(std::out_of_range &_e) {
87176         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87177         return 0;
87178       }
87179       catch(std::invalid_argument &_e) {
87180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87181         return 0;
87182       }
87183
87184     } catch (std::out_of_range& e) {
87185       {
87186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87187       };
87188     } catch (std::exception& e) {
87189       {
87190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87191       };
87192     } catch (...) {
87193       {
87194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87195       };
87196     }
87197   }
87198   jresult = (void *)result;
87199   return jresult;
87200 }
87201
87202
87203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87204   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87205   int arg2 ;
87206   unsigned int *arg3 = 0 ;
87207   unsigned int temp3 ;
87208
87209   arg1 = (std::vector< unsigned int > *)jarg1;
87210   arg2 = (int)jarg2;
87211   temp3 = (unsigned int)jarg3;
87212   arg3 = &temp3;
87213   {
87214     try {
87215       try {
87216         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87217       }
87218       catch(std::out_of_range &_e) {
87219         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87220         return ;
87221       }
87222
87223     } catch (std::out_of_range& e) {
87224       {
87225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87226       };
87227     } catch (std::exception& e) {
87228       {
87229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87230       };
87231     } catch (...) {
87232       {
87233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87234       };
87235     }
87236   }
87237 }
87238
87239
87240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87241   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87242   int arg2 ;
87243   std::vector< unsigned int > *arg3 = 0 ;
87244
87245   arg1 = (std::vector< unsigned int > *)jarg1;
87246   arg2 = (int)jarg2;
87247   arg3 = (std::vector< unsigned int > *)jarg3;
87248   if (!arg3) {
87249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87250     return ;
87251   }
87252   {
87253     try {
87254       try {
87255         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87256       }
87257       catch(std::out_of_range &_e) {
87258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87259         return ;
87260       }
87261
87262     } catch (std::out_of_range& e) {
87263       {
87264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87265       };
87266     } catch (std::exception& e) {
87267       {
87268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87269       };
87270     } catch (...) {
87271       {
87272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87273       };
87274     }
87275   }
87276 }
87277
87278
87279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87280   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87281   int arg2 ;
87282
87283   arg1 = (std::vector< unsigned int > *)jarg1;
87284   arg2 = (int)jarg2;
87285   {
87286     try {
87287       try {
87288         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87289       }
87290       catch(std::out_of_range &_e) {
87291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87292         return ;
87293       }
87294
87295     } catch (std::out_of_range& e) {
87296       {
87297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87298       };
87299     } catch (std::exception& e) {
87300       {
87301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87302       };
87303     } catch (...) {
87304       {
87305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87306       };
87307     }
87308   }
87309 }
87310
87311
87312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87313   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87314   int arg2 ;
87315   int arg3 ;
87316
87317   arg1 = (std::vector< unsigned int > *)jarg1;
87318   arg2 = (int)jarg2;
87319   arg3 = (int)jarg3;
87320   {
87321     try {
87322       try {
87323         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87324       }
87325       catch(std::out_of_range &_e) {
87326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87327         return ;
87328       }
87329       catch(std::invalid_argument &_e) {
87330         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87331         return ;
87332       }
87333
87334     } catch (std::out_of_range& e) {
87335       {
87336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87337       };
87338     } catch (std::exception& e) {
87339       {
87340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87341       };
87342     } catch (...) {
87343       {
87344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87345       };
87346     }
87347   }
87348 }
87349
87350
87351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87352   void * jresult ;
87353   unsigned int *arg1 = 0 ;
87354   int arg2 ;
87355   unsigned int temp1 ;
87356   std::vector< unsigned int > *result = 0 ;
87357
87358   temp1 = (unsigned int)jarg1;
87359   arg1 = &temp1;
87360   arg2 = (int)jarg2;
87361   {
87362     try {
87363       try {
87364         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87365       }
87366       catch(std::out_of_range &_e) {
87367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87368         return 0;
87369       }
87370
87371     } catch (std::out_of_range& e) {
87372       {
87373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87374       };
87375     } catch (std::exception& e) {
87376       {
87377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87378       };
87379     } catch (...) {
87380       {
87381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87382       };
87383     }
87384   }
87385   jresult = (void *)result;
87386   return jresult;
87387 }
87388
87389
87390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87391   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87392
87393   arg1 = (std::vector< unsigned int > *)jarg1;
87394   {
87395     try {
87396       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87397     } catch (std::out_of_range& e) {
87398       {
87399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87400       };
87401     } catch (std::exception& e) {
87402       {
87403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87404       };
87405     } catch (...) {
87406       {
87407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87408       };
87409     }
87410   }
87411 }
87412
87413
87414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87415   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87416   int arg2 ;
87417   int arg3 ;
87418
87419   arg1 = (std::vector< unsigned int > *)jarg1;
87420   arg2 = (int)jarg2;
87421   arg3 = (int)jarg3;
87422   {
87423     try {
87424       try {
87425         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87426       }
87427       catch(std::out_of_range &_e) {
87428         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87429         return ;
87430       }
87431       catch(std::invalid_argument &_e) {
87432         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87433         return ;
87434       }
87435
87436     } catch (std::out_of_range& e) {
87437       {
87438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87439       };
87440     } catch (std::exception& e) {
87441       {
87442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87443       };
87444     } catch (...) {
87445       {
87446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87447       };
87448     }
87449   }
87450 }
87451
87452
87453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87454   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87455   int arg2 ;
87456   std::vector< unsigned int > *arg3 = 0 ;
87457
87458   arg1 = (std::vector< unsigned int > *)jarg1;
87459   arg2 = (int)jarg2;
87460   arg3 = (std::vector< unsigned int > *)jarg3;
87461   if (!arg3) {
87462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87463     return ;
87464   }
87465   {
87466     try {
87467       try {
87468         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87469       }
87470       catch(std::out_of_range &_e) {
87471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87472         return ;
87473       }
87474
87475     } catch (std::out_of_range& e) {
87476       {
87477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87478       };
87479     } catch (std::exception& e) {
87480       {
87481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87482       };
87483     } catch (...) {
87484       {
87485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87486       };
87487     }
87488   }
87489 }
87490
87491
87492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87493   unsigned int jresult ;
87494   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87495   unsigned int *arg2 = 0 ;
87496   unsigned int temp2 ;
87497   bool result;
87498
87499   arg1 = (std::vector< unsigned int > *)jarg1;
87500   temp2 = (unsigned int)jarg2;
87501   arg2 = &temp2;
87502   {
87503     try {
87504       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87505     } catch (std::out_of_range& e) {
87506       {
87507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87508       };
87509     } catch (std::exception& e) {
87510       {
87511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87512       };
87513     } catch (...) {
87514       {
87515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87516       };
87517     }
87518   }
87519   jresult = result;
87520   return jresult;
87521 }
87522
87523
87524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87525   int jresult ;
87526   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87527   unsigned int *arg2 = 0 ;
87528   unsigned int temp2 ;
87529   int result;
87530
87531   arg1 = (std::vector< unsigned int > *)jarg1;
87532   temp2 = (unsigned int)jarg2;
87533   arg2 = &temp2;
87534   {
87535     try {
87536       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87537     } catch (std::out_of_range& e) {
87538       {
87539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87540       };
87541     } catch (std::exception& e) {
87542       {
87543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87544       };
87545     } catch (...) {
87546       {
87547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87548       };
87549     }
87550   }
87551   jresult = result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87557   int jresult ;
87558   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87559   unsigned int *arg2 = 0 ;
87560   unsigned int temp2 ;
87561   int result;
87562
87563   arg1 = (std::vector< unsigned int > *)jarg1;
87564   temp2 = (unsigned int)jarg2;
87565   arg2 = &temp2;
87566   {
87567     try {
87568       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87569     } catch (std::out_of_range& e) {
87570       {
87571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87572       };
87573     } catch (std::exception& e) {
87574       {
87575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87576       };
87577     } catch (...) {
87578       {
87579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87580       };
87581     }
87582   }
87583   jresult = result;
87584   return jresult;
87585 }
87586
87587
87588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87589   unsigned int jresult ;
87590   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87591   unsigned int *arg2 = 0 ;
87592   unsigned int temp2 ;
87593   bool result;
87594
87595   arg1 = (std::vector< unsigned int > *)jarg1;
87596   temp2 = (unsigned int)jarg2;
87597   arg2 = &temp2;
87598   {
87599     try {
87600       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87601     } catch (std::out_of_range& e) {
87602       {
87603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87604       };
87605     } catch (std::exception& e) {
87606       {
87607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87608       };
87609     } catch (...) {
87610       {
87611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87612       };
87613     }
87614   }
87615   jresult = result;
87616   return jresult;
87617 }
87618
87619
87620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87621   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87622
87623   arg1 = (std::vector< unsigned int > *)jarg1;
87624   {
87625     try {
87626       delete arg1;
87627     } catch (std::out_of_range& e) {
87628       {
87629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87630       };
87631     } catch (std::exception& e) {
87632       {
87633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87634       };
87635     } catch (...) {
87636       {
87637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87638       };
87639     }
87640   }
87641 }
87642
87643
87644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87645   void * jresult ;
87646   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87647
87648   {
87649     try {
87650       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (...) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87662       };
87663     }
87664   }
87665   jresult = (void *)result;
87666   return jresult;
87667 }
87668
87669
87670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87671   void * jresult ;
87672   unsigned int arg1 ;
87673   Dali::Actor arg2 ;
87674   Dali::Actor *argp2 ;
87675   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87676
87677   arg1 = (unsigned int)jarg1;
87678   argp2 = (Dali::Actor *)jarg2;
87679   if (!argp2) {
87680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87681     return 0;
87682   }
87683   arg2 = *argp2;
87684   {
87685     try {
87686       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87687     } catch (std::out_of_range& e) {
87688       {
87689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87690       };
87691     } catch (std::exception& e) {
87692       {
87693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87694       };
87695     } catch (...) {
87696       {
87697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87698       };
87699     }
87700   }
87701   jresult = (void *)result;
87702   return jresult;
87703 }
87704
87705
87706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87707   void * jresult ;
87708   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87709   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87710
87711   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87712   if (!arg1) {
87713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87714     return 0;
87715   }
87716   {
87717     try {
87718       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87719     } catch (std::out_of_range& e) {
87720       {
87721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87722       };
87723     } catch (std::exception& e) {
87724       {
87725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87726       };
87727     } catch (...) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87730       };
87731     }
87732   }
87733   jresult = (void *)result;
87734   return jresult;
87735 }
87736
87737
87738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87739   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87740   unsigned int arg2 ;
87741
87742   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87743   arg2 = (unsigned int)jarg2;
87744   if (arg1) (arg1)->first = arg2;
87745 }
87746
87747
87748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87749   unsigned int jresult ;
87750   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87751   unsigned int result;
87752
87753   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87754   result = (unsigned int) ((arg1)->first);
87755   jresult = result;
87756   return jresult;
87757 }
87758
87759
87760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87761   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87762   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87763
87764   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87765   arg2 = (Dali::Actor *)jarg2;
87766   if (arg1) (arg1)->second = *arg2;
87767 }
87768
87769
87770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87771   void * jresult ;
87772   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87773   Dali::Actor *result = 0 ;
87774
87775   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87776   result = (Dali::Actor *)& ((arg1)->second);
87777   jresult = (void *)result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87783   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87784
87785   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87786   {
87787     try {
87788       delete arg1;
87789     } catch (std::out_of_range& e) {
87790       {
87791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87792       };
87793     } catch (std::exception& e) {
87794       {
87795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87796       };
87797     } catch (...) {
87798       {
87799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87800       };
87801     }
87802   }
87803 }
87804
87805
87806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87807   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87808
87809   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87810   {
87811     try {
87812       (arg1)->clear();
87813     } catch (std::out_of_range& e) {
87814       {
87815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87816       };
87817     } catch (std::exception& e) {
87818       {
87819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87824       };
87825     }
87826   }
87827 }
87828
87829
87830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87831   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87832   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87833
87834   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87835   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87836   if (!arg2) {
87837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87838     return ;
87839   }
87840   {
87841     try {
87842       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87843     } catch (std::out_of_range& e) {
87844       {
87845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87846       };
87847     } catch (std::exception& e) {
87848       {
87849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87850       };
87851     } catch (...) {
87852       {
87853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87854       };
87855     }
87856   }
87857 }
87858
87859
87860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87861   unsigned long jresult ;
87862   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87863   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87864
87865   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87866   {
87867     try {
87868       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87869     } catch (std::out_of_range& e) {
87870       {
87871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87872       };
87873     } catch (std::exception& e) {
87874       {
87875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87876       };
87877     } catch (...) {
87878       {
87879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87880       };
87881     }
87882   }
87883   jresult = (unsigned long)result;
87884   return jresult;
87885 }
87886
87887
87888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87889   unsigned long jresult ;
87890   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87891   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87892
87893   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87894   {
87895     try {
87896       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87897     } catch (std::out_of_range& e) {
87898       {
87899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87900       };
87901     } catch (std::exception& e) {
87902       {
87903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87904       };
87905     } catch (...) {
87906       {
87907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87908       };
87909     }
87910   }
87911   jresult = (unsigned long)result;
87912   return jresult;
87913 }
87914
87915
87916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87917   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87918   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87919
87920   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87921   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87922   {
87923     try {
87924       (arg1)->reserve(arg2);
87925     } catch (std::out_of_range& e) {
87926       {
87927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87928       };
87929     } catch (std::exception& e) {
87930       {
87931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87932       };
87933     } catch (...) {
87934       {
87935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87936       };
87937     }
87938   }
87939 }
87940
87941
87942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87943   void * jresult ;
87944   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87945
87946   {
87947     try {
87948       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87949     } catch (std::out_of_range& e) {
87950       {
87951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87952       };
87953     } catch (std::exception& e) {
87954       {
87955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87956       };
87957     } catch (...) {
87958       {
87959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87960       };
87961     }
87962   }
87963   jresult = (void *)result;
87964   return jresult;
87965 }
87966
87967
87968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87969   void * jresult ;
87970   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87971   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87972
87973   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87974   if (!arg1) {
87975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87976     return 0;
87977   }
87978   {
87979     try {
87980       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);
87981     } catch (std::out_of_range& e) {
87982       {
87983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87984       };
87985     } catch (std::exception& e) {
87986       {
87987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87988       };
87989     } catch (...) {
87990       {
87991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87992       };
87993     }
87994   }
87995   jresult = (void *)result;
87996   return jresult;
87997 }
87998
87999
88000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88001   void * jresult ;
88002   int arg1 ;
88003   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88004
88005   arg1 = (int)jarg1;
88006   {
88007     try {
88008       try {
88009         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);
88010       }
88011       catch(std::out_of_range &_e) {
88012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88013         return 0;
88014       }
88015
88016     } catch (std::out_of_range& e) {
88017       {
88018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (std::exception& e) {
88021       {
88022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88023       };
88024     } catch (...) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88027       };
88028     }
88029   }
88030   jresult = (void *)result;
88031   return jresult;
88032 }
88033
88034
88035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88036   void * jresult ;
88037   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88038   int arg2 ;
88039   std::pair< unsigned int,Dali::Actor > result;
88040
88041   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88042   arg2 = (int)jarg2;
88043   {
88044     try {
88045       try {
88046         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88047       }
88048       catch(std::out_of_range &_e) {
88049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88050         return 0;
88051       }
88052
88053     } catch (std::out_of_range& e) {
88054       {
88055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88056       };
88057     } catch (std::exception& e) {
88058       {
88059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88060       };
88061     } catch (...) {
88062       {
88063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88064       };
88065     }
88066   }
88067   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88068   return jresult;
88069 }
88070
88071
88072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88073   void * jresult ;
88074   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88075   int arg2 ;
88076   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88077
88078   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88079   arg2 = (int)jarg2;
88080   {
88081     try {
88082       try {
88083         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88084       }
88085       catch(std::out_of_range &_e) {
88086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88087         return 0;
88088       }
88089
88090     } catch (std::out_of_range& e) {
88091       {
88092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88093       };
88094     } catch (std::exception& e) {
88095       {
88096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (...) {
88099       {
88100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88101       };
88102     }
88103   }
88104   jresult = (void *)result;
88105   return jresult;
88106 }
88107
88108
88109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88110   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88111   int arg2 ;
88112   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88113
88114   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88115   arg2 = (int)jarg2;
88116   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88117   if (!arg3) {
88118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88119     return ;
88120   }
88121   {
88122     try {
88123       try {
88124         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);
88125       }
88126       catch(std::out_of_range &_e) {
88127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88128         return ;
88129       }
88130
88131     } catch (std::out_of_range& e) {
88132       {
88133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88134       };
88135     } catch (std::exception& e) {
88136       {
88137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88138       };
88139     } catch (...) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88142       };
88143     }
88144   }
88145 }
88146
88147
88148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88149   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88150   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88151
88152   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88153   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88154   if (!arg2) {
88155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88156     return ;
88157   }
88158   {
88159     try {
88160       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);
88161     } catch (std::out_of_range& e) {
88162       {
88163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88164       };
88165     } catch (std::exception& e) {
88166       {
88167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88168       };
88169     } catch (...) {
88170       {
88171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88172       };
88173     }
88174   }
88175 }
88176
88177
88178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88179   void * jresult ;
88180   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88181   int arg2 ;
88182   int arg3 ;
88183   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88184
88185   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88186   arg2 = (int)jarg2;
88187   arg3 = (int)jarg3;
88188   {
88189     try {
88190       try {
88191         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);
88192       }
88193       catch(std::out_of_range &_e) {
88194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88195         return 0;
88196       }
88197       catch(std::invalid_argument &_e) {
88198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88199         return 0;
88200       }
88201
88202     } catch (std::out_of_range& e) {
88203       {
88204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88205       };
88206     } catch (std::exception& e) {
88207       {
88208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (...) {
88211       {
88212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88213       };
88214     }
88215   }
88216   jresult = (void *)result;
88217   return jresult;
88218 }
88219
88220
88221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88222   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88223   int arg2 ;
88224   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88225
88226   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88227   arg2 = (int)jarg2;
88228   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88229   if (!arg3) {
88230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88231     return ;
88232   }
88233   {
88234     try {
88235       try {
88236         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);
88237       }
88238       catch(std::out_of_range &_e) {
88239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88240         return ;
88241       }
88242
88243     } catch (std::out_of_range& e) {
88244       {
88245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88246       };
88247     } catch (std::exception& e) {
88248       {
88249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88250       };
88251     } catch (...) {
88252       {
88253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88254       };
88255     }
88256   }
88257 }
88258
88259
88260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88261   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88262   int arg2 ;
88263   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88264
88265   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88266   arg2 = (int)jarg2;
88267   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88268   if (!arg3) {
88269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88270     return ;
88271   }
88272   {
88273     try {
88274       try {
88275         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);
88276       }
88277       catch(std::out_of_range &_e) {
88278         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88279         return ;
88280       }
88281
88282     } catch (std::out_of_range& e) {
88283       {
88284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88285       };
88286     } catch (std::exception& e) {
88287       {
88288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88289       };
88290     } catch (...) {
88291       {
88292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88293       };
88294     }
88295   }
88296 }
88297
88298
88299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88301   int arg2 ;
88302
88303   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88304   arg2 = (int)jarg2;
88305   {
88306     try {
88307       try {
88308         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88309       }
88310       catch(std::out_of_range &_e) {
88311         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88312         return ;
88313       }
88314
88315     } catch (std::out_of_range& e) {
88316       {
88317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88318       };
88319     } catch (std::exception& e) {
88320       {
88321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88322       };
88323     } catch (...) {
88324       {
88325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88326       };
88327     }
88328   }
88329 }
88330
88331
88332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88333   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88334   int arg2 ;
88335   int arg3 ;
88336
88337   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88338   arg2 = (int)jarg2;
88339   arg3 = (int)jarg3;
88340   {
88341     try {
88342       try {
88343         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88344       }
88345       catch(std::out_of_range &_e) {
88346         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88347         return ;
88348       }
88349       catch(std::invalid_argument &_e) {
88350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88351         return ;
88352       }
88353
88354     } catch (std::out_of_range& e) {
88355       {
88356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88357       };
88358     } catch (std::exception& e) {
88359       {
88360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88361       };
88362     } catch (...) {
88363       {
88364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88365       };
88366     }
88367   }
88368 }
88369
88370
88371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88372   void * jresult ;
88373   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88374   int arg2 ;
88375   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88376
88377   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88378   if (!arg1) {
88379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88380     return 0;
88381   }
88382   arg2 = (int)jarg2;
88383   {
88384     try {
88385       try {
88386         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);
88387       }
88388       catch(std::out_of_range &_e) {
88389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88390         return 0;
88391       }
88392
88393     } catch (std::out_of_range& e) {
88394       {
88395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88396       };
88397     } catch (std::exception& e) {
88398       {
88399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88400       };
88401     } catch (...) {
88402       {
88403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88404       };
88405     }
88406   }
88407   jresult = (void *)result;
88408   return jresult;
88409 }
88410
88411
88412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88413   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88414
88415   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88416   {
88417     try {
88418       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88419     } catch (std::out_of_range& e) {
88420       {
88421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88422       };
88423     } catch (std::exception& e) {
88424       {
88425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88426       };
88427     } catch (...) {
88428       {
88429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88430       };
88431     }
88432   }
88433 }
88434
88435
88436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88437   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88438   int arg2 ;
88439   int arg3 ;
88440
88441   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88442   arg2 = (int)jarg2;
88443   arg3 = (int)jarg3;
88444   {
88445     try {
88446       try {
88447         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88448       }
88449       catch(std::out_of_range &_e) {
88450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88451         return ;
88452       }
88453       catch(std::invalid_argument &_e) {
88454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88455         return ;
88456       }
88457
88458     } catch (std::out_of_range& e) {
88459       {
88460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88461       };
88462     } catch (std::exception& e) {
88463       {
88464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88469       };
88470     }
88471   }
88472 }
88473
88474
88475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88476   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88477   int arg2 ;
88478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88479
88480   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88481   arg2 = (int)jarg2;
88482   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88483   if (!arg3) {
88484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88485     return ;
88486   }
88487   {
88488     try {
88489       try {
88490         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);
88491       }
88492       catch(std::out_of_range &_e) {
88493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88494         return ;
88495       }
88496
88497     } catch (std::out_of_range& e) {
88498       {
88499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88500       };
88501     } catch (std::exception& e) {
88502       {
88503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88504       };
88505     } catch (...) {
88506       {
88507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88508       };
88509     }
88510   }
88511 }
88512
88513
88514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88515   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88516
88517   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88518   {
88519     try {
88520       delete arg1;
88521     } catch (std::out_of_range& e) {
88522       {
88523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88524       };
88525     } catch (std::exception& e) {
88526       {
88527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88528       };
88529     } catch (...) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88532       };
88533     }
88534   }
88535 }
88536
88537
88538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88539   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88540
88541   arg1 = (std::vector< Dali::Actor > *)jarg1;
88542   {
88543     try {
88544       (arg1)->clear();
88545     } catch (std::out_of_range& e) {
88546       {
88547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88548       };
88549     } catch (std::exception& e) {
88550       {
88551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88552       };
88553     } catch (...) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88556       };
88557     }
88558   }
88559 }
88560
88561
88562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88563   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88564   Dali::Actor *arg2 = 0 ;
88565
88566   arg1 = (std::vector< Dali::Actor > *)jarg1;
88567   arg2 = (Dali::Actor *)jarg2;
88568   if (!arg2) {
88569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88570     return ;
88571   }
88572   {
88573     try {
88574       (arg1)->push_back((Dali::Actor const &)*arg2);
88575     } catch (std::out_of_range& e) {
88576       {
88577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88578       };
88579     } catch (std::exception& e) {
88580       {
88581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88582       };
88583     } catch (...) {
88584       {
88585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88586       };
88587     }
88588   }
88589 }
88590
88591
88592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88593   unsigned long jresult ;
88594   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88595   std::vector< Dali::Actor >::size_type result;
88596
88597   arg1 = (std::vector< Dali::Actor > *)jarg1;
88598   {
88599     try {
88600       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88601     } catch (std::out_of_range& e) {
88602       {
88603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (std::exception& e) {
88606       {
88607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88612       };
88613     }
88614   }
88615   jresult = (unsigned long)result;
88616   return jresult;
88617 }
88618
88619
88620 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88621   unsigned long jresult ;
88622   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88623   std::vector< Dali::Actor >::size_type result;
88624
88625   arg1 = (std::vector< Dali::Actor > *)jarg1;
88626   {
88627     try {
88628       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88629     } catch (std::out_of_range& e) {
88630       {
88631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88632       };
88633     } catch (std::exception& e) {
88634       {
88635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88636       };
88637     } catch (...) {
88638       {
88639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88640       };
88641     }
88642   }
88643   jresult = (unsigned long)result;
88644   return jresult;
88645 }
88646
88647
88648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88649   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88650   std::vector< Dali::Actor >::size_type arg2 ;
88651
88652   arg1 = (std::vector< Dali::Actor > *)jarg1;
88653   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88654   {
88655     try {
88656       (arg1)->reserve(arg2);
88657     } catch (std::out_of_range& e) {
88658       {
88659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88660       };
88661     } catch (std::exception& e) {
88662       {
88663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88664       };
88665     } catch (...) {
88666       {
88667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88668       };
88669     }
88670   }
88671 }
88672
88673
88674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88675   void * jresult ;
88676   std::vector< Dali::Actor > *result = 0 ;
88677
88678   {
88679     try {
88680       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88681     } catch (std::out_of_range& e) {
88682       {
88683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88684       };
88685     } catch (std::exception& e) {
88686       {
88687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88688       };
88689     } catch (...) {
88690       {
88691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88692       };
88693     }
88694   }
88695   jresult = (void *)result;
88696   return jresult;
88697 }
88698
88699
88700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88701   void * jresult ;
88702   std::vector< Dali::Actor > *arg1 = 0 ;
88703   std::vector< Dali::Actor > *result = 0 ;
88704
88705   arg1 = (std::vector< Dali::Actor > *)jarg1;
88706   if (!arg1) {
88707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88708     return 0;
88709   }
88710   {
88711     try {
88712       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88713     } catch (std::out_of_range& e) {
88714       {
88715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88716       };
88717     } catch (std::exception& e) {
88718       {
88719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88720       };
88721     } catch (...) {
88722       {
88723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88724       };
88725     }
88726   }
88727   jresult = (void *)result;
88728   return jresult;
88729 }
88730
88731
88732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88733   void * jresult ;
88734   int arg1 ;
88735   std::vector< Dali::Actor > *result = 0 ;
88736
88737   arg1 = (int)jarg1;
88738   {
88739     try {
88740       try {
88741         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88742       }
88743       catch(std::out_of_range &_e) {
88744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88745         return 0;
88746       }
88747
88748     } catch (std::out_of_range& e) {
88749       {
88750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (std::exception& e) {
88753       {
88754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88759       };
88760     }
88761   }
88762   jresult = (void *)result;
88763   return jresult;
88764 }
88765
88766
88767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88768   void * jresult ;
88769   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88770   int arg2 ;
88771   Dali::Actor result;
88772
88773   arg1 = (std::vector< Dali::Actor > *)jarg1;
88774   arg2 = (int)jarg2;
88775   {
88776     try {
88777       try {
88778         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88779       }
88780       catch(std::out_of_range &_e) {
88781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88782         return 0;
88783       }
88784
88785     } catch (std::out_of_range& e) {
88786       {
88787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88788       };
88789     } catch (std::exception& e) {
88790       {
88791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88792       };
88793     } catch (...) {
88794       {
88795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88796       };
88797     }
88798   }
88799   jresult = new Dali::Actor((const Dali::Actor &)result);
88800   return jresult;
88801 }
88802
88803
88804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88805   void * jresult ;
88806   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88807   int arg2 ;
88808   Dali::Actor *result = 0 ;
88809
88810   arg1 = (std::vector< Dali::Actor > *)jarg1;
88811   arg2 = (int)jarg2;
88812   {
88813     try {
88814       try {
88815         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88816       }
88817       catch(std::out_of_range &_e) {
88818         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88819         return 0;
88820       }
88821
88822     } catch (std::out_of_range& e) {
88823       {
88824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88825       };
88826     } catch (std::exception& e) {
88827       {
88828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88829       };
88830     } catch (...) {
88831       {
88832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88833       };
88834     }
88835   }
88836   jresult = (void *)result;
88837   return jresult;
88838 }
88839
88840
88841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88842   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88843   int arg2 ;
88844   Dali::Actor *arg3 = 0 ;
88845
88846   arg1 = (std::vector< Dali::Actor > *)jarg1;
88847   arg2 = (int)jarg2;
88848   arg3 = (Dali::Actor *)jarg3;
88849   if (!arg3) {
88850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88851     return ;
88852   }
88853   {
88854     try {
88855       try {
88856         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88857       }
88858       catch(std::out_of_range &_e) {
88859         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88860         return ;
88861       }
88862
88863     } catch (std::out_of_range& e) {
88864       {
88865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88866       };
88867     } catch (std::exception& e) {
88868       {
88869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88870       };
88871     } catch (...) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88874       };
88875     }
88876   }
88877 }
88878
88879
88880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88881   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88882   std::vector< Dali::Actor > *arg2 = 0 ;
88883
88884   arg1 = (std::vector< Dali::Actor > *)jarg1;
88885   arg2 = (std::vector< Dali::Actor > *)jarg2;
88886   if (!arg2) {
88887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88888     return ;
88889   }
88890   {
88891     try {
88892       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88893     } catch (std::out_of_range& e) {
88894       {
88895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88896       };
88897     } catch (std::exception& e) {
88898       {
88899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88900       };
88901     } catch (...) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88904       };
88905     }
88906   }
88907 }
88908
88909
88910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88911   void * jresult ;
88912   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88913   int arg2 ;
88914   int arg3 ;
88915   std::vector< Dali::Actor > *result = 0 ;
88916
88917   arg1 = (std::vector< Dali::Actor > *)jarg1;
88918   arg2 = (int)jarg2;
88919   arg3 = (int)jarg3;
88920   {
88921     try {
88922       try {
88923         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88924       }
88925       catch(std::out_of_range &_e) {
88926         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88927         return 0;
88928       }
88929       catch(std::invalid_argument &_e) {
88930         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88931         return 0;
88932       }
88933
88934     } catch (std::out_of_range& e) {
88935       {
88936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88937       };
88938     } catch (std::exception& e) {
88939       {
88940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88941       };
88942     } catch (...) {
88943       {
88944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88945       };
88946     }
88947   }
88948   jresult = (void *)result;
88949   return jresult;
88950 }
88951
88952
88953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88954   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88955   int arg2 ;
88956   Dali::Actor *arg3 = 0 ;
88957
88958   arg1 = (std::vector< Dali::Actor > *)jarg1;
88959   arg2 = (int)jarg2;
88960   arg3 = (Dali::Actor *)jarg3;
88961   if (!arg3) {
88962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88963     return ;
88964   }
88965   {
88966     try {
88967       try {
88968         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88969       }
88970       catch(std::out_of_range &_e) {
88971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88972         return ;
88973       }
88974
88975     } catch (std::out_of_range& e) {
88976       {
88977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88978       };
88979     } catch (std::exception& e) {
88980       {
88981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88982       };
88983     } catch (...) {
88984       {
88985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88986       };
88987     }
88988   }
88989 }
88990
88991
88992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88993   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88994   int arg2 ;
88995   std::vector< Dali::Actor > *arg3 = 0 ;
88996
88997   arg1 = (std::vector< Dali::Actor > *)jarg1;
88998   arg2 = (int)jarg2;
88999   arg3 = (std::vector< Dali::Actor > *)jarg3;
89000   if (!arg3) {
89001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89002     return ;
89003   }
89004   {
89005     try {
89006       try {
89007         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89008       }
89009       catch(std::out_of_range &_e) {
89010         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89011         return ;
89012       }
89013
89014     } catch (std::out_of_range& e) {
89015       {
89016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89017       };
89018     } catch (std::exception& e) {
89019       {
89020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89021       };
89022     } catch (...) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89025       };
89026     }
89027   }
89028 }
89029
89030
89031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89032   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89033   int arg2 ;
89034
89035   arg1 = (std::vector< Dali::Actor > *)jarg1;
89036   arg2 = (int)jarg2;
89037   {
89038     try {
89039       try {
89040         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89041       }
89042       catch(std::out_of_range &_e) {
89043         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89044         return ;
89045       }
89046
89047     } catch (std::out_of_range& e) {
89048       {
89049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89050       };
89051     } catch (std::exception& e) {
89052       {
89053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89054       };
89055     } catch (...) {
89056       {
89057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89058       };
89059     }
89060   }
89061 }
89062
89063
89064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89065   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89066   int arg2 ;
89067   int arg3 ;
89068
89069   arg1 = (std::vector< Dali::Actor > *)jarg1;
89070   arg2 = (int)jarg2;
89071   arg3 = (int)jarg3;
89072   {
89073     try {
89074       try {
89075         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89076       }
89077       catch(std::out_of_range &_e) {
89078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89079         return ;
89080       }
89081       catch(std::invalid_argument &_e) {
89082         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89083         return ;
89084       }
89085
89086     } catch (std::out_of_range& e) {
89087       {
89088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89089       };
89090     } catch (std::exception& e) {
89091       {
89092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89093       };
89094     } catch (...) {
89095       {
89096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89097       };
89098     }
89099   }
89100 }
89101
89102
89103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89104   void * jresult ;
89105   Dali::Actor *arg1 = 0 ;
89106   int arg2 ;
89107   std::vector< Dali::Actor > *result = 0 ;
89108
89109   arg1 = (Dali::Actor *)jarg1;
89110   if (!arg1) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89112     return 0;
89113   }
89114   arg2 = (int)jarg2;
89115   {
89116     try {
89117       try {
89118         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89119       }
89120       catch(std::out_of_range &_e) {
89121         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89122         return 0;
89123       }
89124
89125     } catch (std::out_of_range& e) {
89126       {
89127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89128       };
89129     } catch (std::exception& e) {
89130       {
89131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89132       };
89133     } catch (...) {
89134       {
89135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89136       };
89137     }
89138   }
89139   jresult = (void *)result;
89140   return jresult;
89141 }
89142
89143
89144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89145   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89146
89147   arg1 = (std::vector< Dali::Actor > *)jarg1;
89148   {
89149     try {
89150       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89151     } catch (std::out_of_range& e) {
89152       {
89153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89154       };
89155     } catch (std::exception& e) {
89156       {
89157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89158       };
89159     } catch (...) {
89160       {
89161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89162       };
89163     }
89164   }
89165 }
89166
89167
89168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89169   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89170   int arg2 ;
89171   int arg3 ;
89172
89173   arg1 = (std::vector< Dali::Actor > *)jarg1;
89174   arg2 = (int)jarg2;
89175   arg3 = (int)jarg3;
89176   {
89177     try {
89178       try {
89179         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89180       }
89181       catch(std::out_of_range &_e) {
89182         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89183         return ;
89184       }
89185       catch(std::invalid_argument &_e) {
89186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89187         return ;
89188       }
89189
89190     } catch (std::out_of_range& e) {
89191       {
89192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89193       };
89194     } catch (std::exception& e) {
89195       {
89196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89197       };
89198     } catch (...) {
89199       {
89200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89201       };
89202     }
89203   }
89204 }
89205
89206
89207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89208   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89209   int arg2 ;
89210   std::vector< Dali::Actor > *arg3 = 0 ;
89211
89212   arg1 = (std::vector< Dali::Actor > *)jarg1;
89213   arg2 = (int)jarg2;
89214   arg3 = (std::vector< Dali::Actor > *)jarg3;
89215   if (!arg3) {
89216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89217     return ;
89218   }
89219   {
89220     try {
89221       try {
89222         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89223       }
89224       catch(std::out_of_range &_e) {
89225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89226         return ;
89227       }
89228
89229     } catch (std::out_of_range& e) {
89230       {
89231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89232       };
89233     } catch (std::exception& e) {
89234       {
89235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89236       };
89237     } catch (...) {
89238       {
89239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89240       };
89241     }
89242   }
89243 }
89244
89245
89246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89247   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89248
89249   arg1 = (std::vector< Dali::Actor > *)jarg1;
89250   {
89251     try {
89252       delete arg1;
89253     } catch (std::out_of_range& e) {
89254       {
89255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89256       };
89257     } catch (std::exception& e) {
89258       {
89259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89260       };
89261     } catch (...) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89264       };
89265     }
89266   }
89267 }
89268
89269
89270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89271   unsigned int jresult ;
89272   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89273   bool result;
89274
89275   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89276   {
89277     try {
89278       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89279     } catch (std::out_of_range& e) {
89280       {
89281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89282       };
89283     } catch (std::exception& e) {
89284       {
89285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89286       };
89287     } catch (...) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89290       };
89291     }
89292   }
89293   jresult = result;
89294   return jresult;
89295 }
89296
89297
89298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89299   unsigned long jresult ;
89300   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89301   std::size_t result;
89302
89303   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89304   {
89305     try {
89306       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89307     } catch (std::out_of_range& e) {
89308       {
89309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89310       };
89311     } catch (std::exception& e) {
89312       {
89313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89314       };
89315     } catch (...) {
89316       {
89317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89318       };
89319     }
89320   }
89321   jresult = (unsigned long)result;
89322   return jresult;
89323 }
89324
89325
89326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89327   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89328   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89329
89330   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89331   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89332   {
89333     try {
89334       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89335     } catch (std::out_of_range& e) {
89336       {
89337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89338       };
89339     } catch (std::exception& e) {
89340       {
89341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89342       };
89343     } catch (...) {
89344       {
89345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89346       };
89347     }
89348   }
89349 }
89350
89351
89352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89353   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89354   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89355
89356   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89357   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89358   {
89359     try {
89360       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89361     } catch (std::out_of_range& e) {
89362       {
89363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89364       };
89365     } catch (std::exception& e) {
89366       {
89367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89368       };
89369     } catch (...) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89372       };
89373     }
89374   }
89375 }
89376
89377
89378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89379   unsigned int jresult ;
89380   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89381   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89382   bool result;
89383
89384   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89385   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89386   if (!arg2) {
89387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89388     return 0;
89389   }
89390   {
89391     try {
89392       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89393     } catch (std::out_of_range& e) {
89394       {
89395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (std::exception& e) {
89398       {
89399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89400       };
89401     } catch (...) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89404       };
89405     }
89406   }
89407   jresult = result;
89408   return jresult;
89409 }
89410
89411
89412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89413   void * jresult ;
89414   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89415
89416   {
89417     try {
89418       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89419     } catch (std::out_of_range& e) {
89420       {
89421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89422       };
89423     } catch (std::exception& e) {
89424       {
89425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89426       };
89427     } catch (...) {
89428       {
89429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89430       };
89431     }
89432   }
89433   jresult = (void *)result;
89434   return jresult;
89435 }
89436
89437
89438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89439   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89440
89441   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89442   {
89443     try {
89444       delete arg1;
89445     } catch (std::out_of_range& e) {
89446       {
89447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89448       };
89449     } catch (std::exception& e) {
89450       {
89451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89452       };
89453     } catch (...) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89456       };
89457     }
89458   }
89459 }
89460
89461
89462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89463   unsigned int jresult ;
89464   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89465   bool result;
89466
89467   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89468   {
89469     try {
89470       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);
89471     } catch (std::out_of_range& e) {
89472       {
89473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89474       };
89475     } catch (std::exception& e) {
89476       {
89477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89478       };
89479     } catch (...) {
89480       {
89481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89482       };
89483     }
89484   }
89485   jresult = result;
89486   return jresult;
89487 }
89488
89489
89490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89491   unsigned long jresult ;
89492   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89493   std::size_t result;
89494
89495   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89496   {
89497     try {
89498       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);
89499     } catch (std::out_of_range& e) {
89500       {
89501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89502       };
89503     } catch (std::exception& e) {
89504       {
89505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89506       };
89507     } catch (...) {
89508       {
89509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89510       };
89511     }
89512   }
89513   jresult = (unsigned long)result;
89514   return jresult;
89515 }
89516
89517
89518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89519   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89520   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89521
89522   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89523   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89524   {
89525     try {
89526       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89527     } catch (std::out_of_range& e) {
89528       {
89529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89530       };
89531     } catch (std::exception& e) {
89532       {
89533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89534       };
89535     } catch (...) {
89536       {
89537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89538       };
89539     }
89540   }
89541 }
89542
89543
89544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89545   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89546   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89547
89548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89549   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89550   {
89551     try {
89552       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89553     } catch (std::out_of_range& e) {
89554       {
89555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89556       };
89557     } catch (std::exception& e) {
89558       {
89559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89560       };
89561     } catch (...) {
89562       {
89563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89564       };
89565     }
89566   }
89567 }
89568
89569
89570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89571   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89572   Dali::Actor arg2 ;
89573   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89574   Dali::Actor *argp2 ;
89575
89576   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89577   argp2 = (Dali::Actor *)jarg2;
89578   if (!argp2) {
89579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89580     return ;
89581   }
89582   arg2 = *argp2;
89583   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89584   {
89585     try {
89586       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89587     } catch (std::out_of_range& e) {
89588       {
89589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89590       };
89591     } catch (std::exception& e) {
89592       {
89593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89594       };
89595     } catch (...) {
89596       {
89597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89598       };
89599     }
89600   }
89601 }
89602
89603
89604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89605   void * jresult ;
89606   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89607
89608   {
89609     try {
89610       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89611     } catch (std::out_of_range& e) {
89612       {
89613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89614       };
89615     } catch (std::exception& e) {
89616       {
89617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89618       };
89619     } catch (...) {
89620       {
89621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89622       };
89623     }
89624   }
89625   jresult = (void *)result;
89626   return jresult;
89627 }
89628
89629
89630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89631   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89632
89633   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89634   {
89635     try {
89636       delete arg1;
89637     } catch (std::out_of_range& e) {
89638       {
89639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89640       };
89641     } catch (std::exception& e) {
89642       {
89643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89644       };
89645     } catch (...) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89648       };
89649     }
89650   }
89651 }
89652
89653
89654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89655   unsigned int jresult ;
89656   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89657   bool result;
89658
89659   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89660   {
89661     try {
89662       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89663     } catch (std::out_of_range& e) {
89664       {
89665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89666       };
89667     } catch (std::exception& e) {
89668       {
89669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89670       };
89671     } catch (...) {
89672       {
89673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89674       };
89675     }
89676   }
89677   jresult = result;
89678   return jresult;
89679 }
89680
89681
89682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89683   unsigned long jresult ;
89684   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89685   std::size_t result;
89686
89687   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89688   {
89689     try {
89690       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89691     } catch (std::out_of_range& e) {
89692       {
89693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89694       };
89695     } catch (std::exception& e) {
89696       {
89697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89698       };
89699     } catch (...) {
89700       {
89701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89702       };
89703     }
89704   }
89705   jresult = (unsigned long)result;
89706   return jresult;
89707 }
89708
89709
89710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89711   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89712   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89713
89714   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89715   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89716   {
89717     try {
89718       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89719     } catch (std::out_of_range& e) {
89720       {
89721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89722       };
89723     } catch (std::exception& e) {
89724       {
89725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89726       };
89727     } catch (...) {
89728       {
89729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89730       };
89731     }
89732   }
89733 }
89734
89735
89736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89737   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89738   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89739
89740   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89741   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89742   {
89743     try {
89744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89745     } catch (std::out_of_range& e) {
89746       {
89747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89748       };
89749     } catch (std::exception& e) {
89750       {
89751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89752       };
89753     } catch (...) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89756       };
89757     }
89758   }
89759 }
89760
89761
89762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89763   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89764   Dali::Actor arg2 ;
89765   Dali::Actor arg3 ;
89766   Dali::Actor *argp2 ;
89767   Dali::Actor *argp3 ;
89768
89769   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89770   argp2 = (Dali::Actor *)jarg2;
89771   if (!argp2) {
89772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89773     return ;
89774   }
89775   arg2 = *argp2;
89776   argp3 = (Dali::Actor *)jarg3;
89777   if (!argp3) {
89778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89779     return ;
89780   }
89781   arg3 = *argp3;
89782   {
89783     try {
89784       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89785     } catch (std::out_of_range& e) {
89786       {
89787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89788       };
89789     } catch (std::exception& e) {
89790       {
89791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89792       };
89793     } catch (...) {
89794       {
89795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89796       };
89797     }
89798   }
89799 }
89800
89801
89802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89803   void * jresult ;
89804   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89805
89806   {
89807     try {
89808       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89809     } catch (std::out_of_range& e) {
89810       {
89811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89812       };
89813     } catch (std::exception& e) {
89814       {
89815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89816       };
89817     } catch (...) {
89818       {
89819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89820       };
89821     }
89822   }
89823   jresult = (void *)result;
89824   return jresult;
89825 }
89826
89827
89828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89829   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89830
89831   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89832   {
89833     try {
89834       delete arg1;
89835     } catch (std::out_of_range& e) {
89836       {
89837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89838       };
89839     } catch (std::exception& e) {
89840       {
89841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89842       };
89843     } catch (...) {
89844       {
89845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89846       };
89847     }
89848   }
89849 }
89850
89851
89852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89853   unsigned int jresult ;
89854   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89855   bool result;
89856
89857   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89858   {
89859     try {
89860       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89861     } catch (std::out_of_range& e) {
89862       {
89863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89864       };
89865     } catch (std::exception& e) {
89866       {
89867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89868       };
89869     } catch (...) {
89870       {
89871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89872       };
89873     }
89874   }
89875   jresult = result;
89876   return jresult;
89877 }
89878
89879
89880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89881   unsigned long jresult ;
89882   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89883   std::size_t result;
89884
89885   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89886   {
89887     try {
89888       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89889     } catch (std::out_of_range& e) {
89890       {
89891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89892       };
89893     } catch (std::exception& e) {
89894       {
89895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89896       };
89897     } catch (...) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89900       };
89901     }
89902   }
89903   jresult = (unsigned long)result;
89904   return jresult;
89905 }
89906
89907
89908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89909   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89910   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89911
89912   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89913   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89914   {
89915     try {
89916       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89917     } catch (std::out_of_range& e) {
89918       {
89919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89920       };
89921     } catch (std::exception& e) {
89922       {
89923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89924       };
89925     } catch (...) {
89926       {
89927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89928       };
89929     }
89930   }
89931 }
89932
89933
89934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89935   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89936   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89937
89938   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89939   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89940   {
89941     try {
89942       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89943     } catch (std::out_of_range& e) {
89944       {
89945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89946       };
89947     } catch (std::exception& e) {
89948       {
89949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89950       };
89951     } catch (...) {
89952       {
89953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89954       };
89955     }
89956   }
89957 }
89958
89959
89960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89961   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89962   Dali::Actor arg2 ;
89963   bool arg3 ;
89964   Dali::Actor *argp2 ;
89965
89966   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89967   argp2 = (Dali::Actor *)jarg2;
89968   if (!argp2) {
89969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89970     return ;
89971   }
89972   arg2 = *argp2;
89973   arg3 = jarg3 ? true : false;
89974   {
89975     try {
89976       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89977     } catch (std::out_of_range& e) {
89978       {
89979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89980       };
89981     } catch (std::exception& e) {
89982       {
89983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89984       };
89985     } catch (...) {
89986       {
89987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89988       };
89989     }
89990   }
89991 }
89992
89993
89994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89995   void * jresult ;
89996   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89997
89998   {
89999     try {
90000       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90001     } catch (std::out_of_range& e) {
90002       {
90003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90004       };
90005     } catch (std::exception& e) {
90006       {
90007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90008       };
90009     } catch (...) {
90010       {
90011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90012       };
90013     }
90014   }
90015   jresult = (void *)result;
90016   return jresult;
90017 }
90018
90019
90020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90021   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90022
90023   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90024   {
90025     try {
90026       delete arg1;
90027     } catch (std::out_of_range& e) {
90028       {
90029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90030       };
90031     } catch (std::exception& e) {
90032       {
90033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90034       };
90035     } catch (...) {
90036       {
90037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90038       };
90039     }
90040   }
90041 }
90042
90043
90044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90045   unsigned int jresult ;
90046   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90047   bool result;
90048
90049   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90050   {
90051     try {
90052       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);
90053     } catch (std::out_of_range& e) {
90054       {
90055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90056       };
90057     } catch (std::exception& e) {
90058       {
90059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90060       };
90061     } catch (...) {
90062       {
90063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90064       };
90065     }
90066   }
90067   jresult = result;
90068   return jresult;
90069 }
90070
90071
90072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90073   unsigned long jresult ;
90074   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90075   std::size_t result;
90076
90077   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90078   {
90079     try {
90080       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);
90081     } catch (std::out_of_range& e) {
90082       {
90083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90084       };
90085     } catch (std::exception& e) {
90086       {
90087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90088       };
90089     } catch (...) {
90090       {
90091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90092       };
90093     }
90094   }
90095   jresult = (unsigned long)result;
90096   return jresult;
90097 }
90098
90099
90100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90101   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90102   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90103
90104   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90105   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90106   {
90107     try {
90108       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90109     } catch (std::out_of_range& e) {
90110       {
90111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90112       };
90113     } catch (std::exception& e) {
90114       {
90115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90116       };
90117     } catch (...) {
90118       {
90119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90120       };
90121     }
90122   }
90123 }
90124
90125
90126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90127   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90128   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90129
90130   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90131   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90132   {
90133     try {
90134       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90135     } catch (std::out_of_range& e) {
90136       {
90137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90138       };
90139     } catch (std::exception& e) {
90140       {
90141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90142       };
90143     } catch (...) {
90144       {
90145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90146       };
90147     }
90148   }
90149 }
90150
90151
90152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90153   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90154   Dali::Toolkit::StyleManager arg2 ;
90155   Dali::StyleChange::Type arg3 ;
90156   Dali::Toolkit::StyleManager *argp2 ;
90157
90158   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90159   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90160   if (!argp2) {
90161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90162     return ;
90163   }
90164   arg2 = *argp2;
90165   arg3 = (Dali::StyleChange::Type)jarg3;
90166   {
90167     try {
90168       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90169     } catch (std::out_of_range& e) {
90170       {
90171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90172       };
90173     } catch (std::exception& e) {
90174       {
90175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90176       };
90177     } catch (...) {
90178       {
90179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90180       };
90181     }
90182   }
90183 }
90184
90185
90186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90187   void * jresult ;
90188   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90189
90190   {
90191     try {
90192       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90193     } catch (std::out_of_range& e) {
90194       {
90195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90196       };
90197     } catch (std::exception& e) {
90198       {
90199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90204       };
90205     }
90206   }
90207   jresult = (void *)result;
90208   return jresult;
90209 }
90210
90211
90212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90213   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90214
90215   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90216   {
90217     try {
90218       delete arg1;
90219     } catch (std::out_of_range& e) {
90220       {
90221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90222       };
90223     } catch (std::exception& e) {
90224       {
90225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90226       };
90227     } catch (...) {
90228       {
90229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90230       };
90231     }
90232   }
90233 }
90234
90235
90236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90237   unsigned int jresult ;
90238   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90239   bool result;
90240
90241   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90242   {
90243     try {
90244       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90245     } catch (std::out_of_range& e) {
90246       {
90247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90248       };
90249     } catch (std::exception& e) {
90250       {
90251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90252       };
90253     } catch (...) {
90254       {
90255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90256       };
90257     }
90258   }
90259   jresult = result;
90260   return jresult;
90261 }
90262
90263
90264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90265   unsigned long jresult ;
90266   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90267   std::size_t result;
90268
90269   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90270   {
90271     try {
90272       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90273     } catch (std::out_of_range& e) {
90274       {
90275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (std::exception& e) {
90278       {
90279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90284       };
90285     }
90286   }
90287   jresult = (unsigned long)result;
90288   return jresult;
90289 }
90290
90291
90292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90293   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90294   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90295
90296   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90297   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90298   {
90299     try {
90300       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90301     } catch (std::out_of_range& e) {
90302       {
90303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90304       };
90305     } catch (std::exception& e) {
90306       {
90307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90308       };
90309     } catch (...) {
90310       {
90311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90312       };
90313     }
90314   }
90315 }
90316
90317
90318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90319   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90320   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90321
90322   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90323   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90324   {
90325     try {
90326       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90327     } catch (std::out_of_range& e) {
90328       {
90329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90330       };
90331     } catch (std::exception& e) {
90332       {
90333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90334       };
90335     } catch (...) {
90336       {
90337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90338       };
90339     }
90340   }
90341 }
90342
90343
90344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90345   unsigned int jresult ;
90346   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90347   Dali::Toolkit::Button arg2 ;
90348   Dali::Toolkit::Button *argp2 ;
90349   bool result;
90350
90351   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90352   argp2 = (Dali::Toolkit::Button *)jarg2;
90353   if (!argp2) {
90354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90355     return 0;
90356   }
90357   arg2 = *argp2;
90358   {
90359     try {
90360       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90361     } catch (std::out_of_range& e) {
90362       {
90363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90364       };
90365     } catch (std::exception& e) {
90366       {
90367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90368       };
90369     } catch (...) {
90370       {
90371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90372       };
90373     }
90374   }
90375   jresult = result;
90376   return jresult;
90377 }
90378
90379
90380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90381   void * jresult ;
90382   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90383
90384   {
90385     try {
90386       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90387     } catch (std::out_of_range& e) {
90388       {
90389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90390       };
90391     } catch (std::exception& e) {
90392       {
90393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90394       };
90395     } catch (...) {
90396       {
90397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90398       };
90399     }
90400   }
90401   jresult = (void *)result;
90402   return jresult;
90403 }
90404
90405
90406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90407   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90408
90409   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90410   {
90411     try {
90412       delete arg1;
90413     } catch (std::out_of_range& e) {
90414       {
90415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90416       };
90417     } catch (std::exception& e) {
90418       {
90419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90420       };
90421     } catch (...) {
90422       {
90423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90424       };
90425     }
90426   }
90427 }
90428
90429
90430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90431   unsigned int jresult ;
90432   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90433   bool result;
90434
90435   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90436   {
90437     try {
90438       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90439     } catch (std::out_of_range& e) {
90440       {
90441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90442       };
90443     } catch (std::exception& e) {
90444       {
90445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90446       };
90447     } catch (...) {
90448       {
90449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90450       };
90451     }
90452   }
90453   jresult = result;
90454   return jresult;
90455 }
90456
90457
90458 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90459   unsigned long jresult ;
90460   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90461   std::size_t result;
90462
90463   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90464   {
90465     try {
90466       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90467     } catch (std::out_of_range& e) {
90468       {
90469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90470       };
90471     } catch (std::exception& e) {
90472       {
90473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90474       };
90475     } catch (...) {
90476       {
90477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90478       };
90479     }
90480   }
90481   jresult = (unsigned long)result;
90482   return jresult;
90483 }
90484
90485
90486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90487   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90488   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90489
90490   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90491   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90492   {
90493     try {
90494       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90495     } catch (std::out_of_range& e) {
90496       {
90497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90498       };
90499     } catch (std::exception& e) {
90500       {
90501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90502       };
90503     } catch (...) {
90504       {
90505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90506       };
90507     }
90508   }
90509 }
90510
90511
90512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90513   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90514   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90515
90516   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90517   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90518   {
90519     try {
90520       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90521     } catch (std::out_of_range& e) {
90522       {
90523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90524       };
90525     } catch (std::exception& e) {
90526       {
90527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90528       };
90529     } catch (...) {
90530       {
90531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90532       };
90533     }
90534   }
90535 }
90536
90537
90538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90539   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90540   Dali::Toolkit::GaussianBlurView arg2 ;
90541   Dali::Toolkit::GaussianBlurView *argp2 ;
90542
90543   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90544   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90545   if (!argp2) {
90546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90547     return ;
90548   }
90549   arg2 = *argp2;
90550   {
90551     try {
90552       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90553     } catch (std::out_of_range& e) {
90554       {
90555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90556       };
90557     } catch (std::exception& e) {
90558       {
90559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90560       };
90561     } catch (...) {
90562       {
90563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90564       };
90565     }
90566   }
90567 }
90568
90569
90570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90571   void * jresult ;
90572   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90573
90574   {
90575     try {
90576       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90577     } catch (std::out_of_range& e) {
90578       {
90579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90580       };
90581     } catch (std::exception& e) {
90582       {
90583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (...) {
90586       {
90587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90588       };
90589     }
90590   }
90591   jresult = (void *)result;
90592   return jresult;
90593 }
90594
90595
90596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90597   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90598
90599   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90600   {
90601     try {
90602       delete arg1;
90603     } catch (std::out_of_range& e) {
90604       {
90605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90606       };
90607     } catch (std::exception& e) {
90608       {
90609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90610       };
90611     } catch (...) {
90612       {
90613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90614       };
90615     }
90616   }
90617 }
90618
90619
90620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90621   unsigned int jresult ;
90622   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90623   bool result;
90624
90625   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90626   {
90627     try {
90628       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);
90629     } catch (std::out_of_range& e) {
90630       {
90631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90632       };
90633     } catch (std::exception& e) {
90634       {
90635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90636       };
90637     } catch (...) {
90638       {
90639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90640       };
90641     }
90642   }
90643   jresult = result;
90644   return jresult;
90645 }
90646
90647
90648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90649   unsigned long jresult ;
90650   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90651   std::size_t result;
90652
90653   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90654   {
90655     try {
90656       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);
90657     } catch (std::out_of_range& e) {
90658       {
90659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90660       };
90661     } catch (std::exception& e) {
90662       {
90663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90664       };
90665     } catch (...) {
90666       {
90667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90668       };
90669     }
90670   }
90671   jresult = (unsigned long)result;
90672   return jresult;
90673 }
90674
90675
90676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90677   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90678   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90679
90680   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90681   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90682   {
90683     try {
90684       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90685     } catch (std::out_of_range& e) {
90686       {
90687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90688       };
90689     } catch (std::exception& e) {
90690       {
90691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90692       };
90693     } catch (...) {
90694       {
90695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90696       };
90697     }
90698   }
90699 }
90700
90701
90702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90703   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90704   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90705
90706   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90707   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90708   {
90709     try {
90710       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90711     } catch (std::out_of_range& e) {
90712       {
90713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90714       };
90715     } catch (std::exception& e) {
90716       {
90717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90718       };
90719     } catch (...) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90722       };
90723     }
90724   }
90725 }
90726
90727
90728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90729   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90730   Dali::Toolkit::PageTurnView arg2 ;
90731   unsigned int arg3 ;
90732   bool arg4 ;
90733   Dali::Toolkit::PageTurnView *argp2 ;
90734
90735   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90736   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90737   if (!argp2) {
90738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90739     return ;
90740   }
90741   arg2 = *argp2;
90742   arg3 = (unsigned int)jarg3;
90743   arg4 = jarg4 ? true : false;
90744   {
90745     try {
90746       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90747     } catch (std::out_of_range& e) {
90748       {
90749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90750       };
90751     } catch (std::exception& e) {
90752       {
90753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90754       };
90755     } catch (...) {
90756       {
90757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90758       };
90759     }
90760   }
90761 }
90762
90763
90764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90765   void * jresult ;
90766   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90767
90768   {
90769     try {
90770       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90771     } catch (std::out_of_range& e) {
90772       {
90773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90774       };
90775     } catch (std::exception& e) {
90776       {
90777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90778       };
90779     } catch (...) {
90780       {
90781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90782       };
90783     }
90784   }
90785   jresult = (void *)result;
90786   return jresult;
90787 }
90788
90789
90790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90791   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90792
90793   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90794   {
90795     try {
90796       delete arg1;
90797     } catch (std::out_of_range& e) {
90798       {
90799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90800       };
90801     } catch (std::exception& e) {
90802       {
90803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90804       };
90805     } catch (...) {
90806       {
90807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90808       };
90809     }
90810   }
90811 }
90812
90813
90814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90815   unsigned int jresult ;
90816   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90817   bool result;
90818
90819   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90820   {
90821     try {
90822       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90823     } catch (std::out_of_range& e) {
90824       {
90825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90826       };
90827     } catch (std::exception& e) {
90828       {
90829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90830       };
90831     } catch (...) {
90832       {
90833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90834       };
90835     }
90836   }
90837   jresult = result;
90838   return jresult;
90839 }
90840
90841
90842 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90843   unsigned long jresult ;
90844   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90845   std::size_t result;
90846
90847   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90848   {
90849     try {
90850       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90851     } catch (std::out_of_range& e) {
90852       {
90853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90854       };
90855     } catch (std::exception& e) {
90856       {
90857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90858       };
90859     } catch (...) {
90860       {
90861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90862       };
90863     }
90864   }
90865   jresult = (unsigned long)result;
90866   return jresult;
90867 }
90868
90869
90870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90871   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90872   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90873
90874   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90875   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90876   {
90877     try {
90878       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90879     } catch (std::out_of_range& e) {
90880       {
90881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90882       };
90883     } catch (std::exception& e) {
90884       {
90885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90886       };
90887     } catch (...) {
90888       {
90889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90890       };
90891     }
90892   }
90893 }
90894
90895
90896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90897   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90898   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90899
90900   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90901   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90902   {
90903     try {
90904       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90905     } catch (std::out_of_range& e) {
90906       {
90907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90908       };
90909     } catch (std::exception& e) {
90910       {
90911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90912       };
90913     } catch (...) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90916       };
90917     }
90918   }
90919 }
90920
90921
90922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90923   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90924   Dali::Toolkit::PageTurnView arg2 ;
90925   Dali::Toolkit::PageTurnView *argp2 ;
90926
90927   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90928   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90929   if (!argp2) {
90930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90931     return ;
90932   }
90933   arg2 = *argp2;
90934   {
90935     try {
90936       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90937     } catch (std::out_of_range& e) {
90938       {
90939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90940       };
90941     } catch (std::exception& e) {
90942       {
90943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90944       };
90945     } catch (...) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90948       };
90949     }
90950   }
90951 }
90952
90953
90954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90955   void * jresult ;
90956   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90957
90958   {
90959     try {
90960       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90968       };
90969     } catch (...) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90972       };
90973     }
90974   }
90975   jresult = (void *)result;
90976   return jresult;
90977 }
90978
90979
90980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90981   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90982
90983   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90984   {
90985     try {
90986       delete arg1;
90987     } catch (std::out_of_range& e) {
90988       {
90989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90990       };
90991     } catch (std::exception& e) {
90992       {
90993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90994       };
90995     } catch (...) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90998       };
90999     }
91000   }
91001 }
91002
91003
91004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91005   unsigned int jresult ;
91006   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91007   bool result;
91008
91009   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91010   {
91011     try {
91012       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);
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91020       };
91021     } catch (...) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91024       };
91025     }
91026   }
91027   jresult = result;
91028   return jresult;
91029 }
91030
91031
91032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91033   unsigned long jresult ;
91034   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91035   std::size_t result;
91036
91037   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91038   {
91039     try {
91040       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);
91041     } catch (std::out_of_range& e) {
91042       {
91043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91044       };
91045     } catch (std::exception& e) {
91046       {
91047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91048       };
91049     } catch (...) {
91050       {
91051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91052       };
91053     }
91054   }
91055   jresult = (unsigned long)result;
91056   return jresult;
91057 }
91058
91059
91060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91061   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91062   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91063
91064   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91065   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91066   {
91067     try {
91068       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91069     } catch (std::out_of_range& e) {
91070       {
91071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91072       };
91073     } catch (std::exception& e) {
91074       {
91075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (...) {
91078       {
91079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91080       };
91081     }
91082   }
91083 }
91084
91085
91086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91087   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91088   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91089
91090   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91091   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91092   {
91093     try {
91094       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91095     } catch (std::out_of_range& e) {
91096       {
91097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91098       };
91099     } catch (std::exception& e) {
91100       {
91101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91102       };
91103     } catch (...) {
91104       {
91105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91106       };
91107     }
91108   }
91109 }
91110
91111
91112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91113   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91114   Dali::Toolkit::ProgressBar arg2 ;
91115   float arg3 ;
91116   float arg4 ;
91117   Dali::Toolkit::ProgressBar *argp2 ;
91118
91119   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91120   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91121   if (!argp2) {
91122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91123     return ;
91124   }
91125   arg2 = *argp2;
91126   arg3 = (float)jarg3;
91127   arg4 = (float)jarg4;
91128   {
91129     try {
91130       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91131     } catch (std::out_of_range& e) {
91132       {
91133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91134       };
91135     } catch (std::exception& e) {
91136       {
91137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91138       };
91139     } catch (...) {
91140       {
91141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91142       };
91143     }
91144   }
91145 }
91146
91147
91148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91149   void * jresult ;
91150   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91151
91152   {
91153     try {
91154       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91155     } catch (std::out_of_range& e) {
91156       {
91157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91158       };
91159     } catch (std::exception& e) {
91160       {
91161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91162       };
91163     } catch (...) {
91164       {
91165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91166       };
91167     }
91168   }
91169   jresult = (void *)result;
91170   return jresult;
91171 }
91172
91173
91174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91175   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91176
91177   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91178   {
91179     try {
91180       delete arg1;
91181     } catch (std::out_of_range& e) {
91182       {
91183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91184       };
91185     } catch (std::exception& e) {
91186       {
91187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91188       };
91189     } catch (...) {
91190       {
91191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91192       };
91193     }
91194   }
91195 }
91196
91197
91198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91199   unsigned int jresult ;
91200   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91201   bool result;
91202
91203   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91204   {
91205     try {
91206       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);
91207     } catch (std::out_of_range& e) {
91208       {
91209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (std::exception& e) {
91212       {
91213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91214       };
91215     } catch (...) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91218       };
91219     }
91220   }
91221   jresult = result;
91222   return jresult;
91223 }
91224
91225
91226 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91227   unsigned long jresult ;
91228   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91229   std::size_t result;
91230
91231   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91232   {
91233     try {
91234       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);
91235     } catch (std::out_of_range& e) {
91236       {
91237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91238       };
91239     } catch (std::exception& e) {
91240       {
91241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91242       };
91243     } catch (...) {
91244       {
91245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91246       };
91247     }
91248   }
91249   jresult = (unsigned long)result;
91250   return jresult;
91251 }
91252
91253
91254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91255   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91256   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91257
91258   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91259   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91260   {
91261     try {
91262       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91263     } catch (std::out_of_range& e) {
91264       {
91265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91266       };
91267     } catch (std::exception& e) {
91268       {
91269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91270       };
91271     } catch (...) {
91272       {
91273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91274       };
91275     }
91276   }
91277 }
91278
91279
91280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91281   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91282   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91283
91284   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91285   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91286   {
91287     try {
91288       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91289     } catch (std::out_of_range& e) {
91290       {
91291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91292       };
91293     } catch (std::exception& e) {
91294       {
91295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91296       };
91297     } catch (...) {
91298       {
91299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91300       };
91301     }
91302   }
91303 }
91304
91305
91306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91307   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91308   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91309
91310   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91311   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91312   if (!arg2) {
91313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91314     return ;
91315   }
91316   {
91317     try {
91318       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91319     } catch (std::out_of_range& e) {
91320       {
91321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91322       };
91323     } catch (std::exception& e) {
91324       {
91325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91326       };
91327     } catch (...) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91330       };
91331     }
91332   }
91333 }
91334
91335
91336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91337   void * jresult ;
91338   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91339
91340   {
91341     try {
91342       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91343     } catch (std::out_of_range& e) {
91344       {
91345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91346       };
91347     } catch (std::exception& e) {
91348       {
91349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91350       };
91351     } catch (...) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91354       };
91355     }
91356   }
91357   jresult = (void *)result;
91358   return jresult;
91359 }
91360
91361
91362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91363   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91364
91365   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91366   {
91367     try {
91368       delete arg1;
91369     } catch (std::out_of_range& e) {
91370       {
91371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (std::exception& e) {
91374       {
91375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91380       };
91381     }
91382   }
91383 }
91384
91385
91386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91387   unsigned int jresult ;
91388   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91389   bool result;
91390
91391   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91392   {
91393     try {
91394       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91395     } catch (std::out_of_range& e) {
91396       {
91397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91398       };
91399     } catch (std::exception& e) {
91400       {
91401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91402       };
91403     } catch (...) {
91404       {
91405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91406       };
91407     }
91408   }
91409   jresult = result;
91410   return jresult;
91411 }
91412
91413
91414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91415   unsigned long jresult ;
91416   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91417   std::size_t result;
91418
91419   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91420   {
91421     try {
91422       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91423     } catch (std::out_of_range& e) {
91424       {
91425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91426       };
91427     } catch (std::exception& e) {
91428       {
91429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91430       };
91431     } catch (...) {
91432       {
91433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91434       };
91435     }
91436   }
91437   jresult = (unsigned long)result;
91438   return jresult;
91439 }
91440
91441
91442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91443   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91444   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91445
91446   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91447   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91448   {
91449     try {
91450       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91458       };
91459     } catch (...) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91462       };
91463     }
91464   }
91465 }
91466
91467
91468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91469   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91470   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91471
91472   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91473   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91474   {
91475     try {
91476       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91477     } catch (std::out_of_range& e) {
91478       {
91479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91480       };
91481     } catch (std::exception& e) {
91482       {
91483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91484       };
91485     } catch (...) {
91486       {
91487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91488       };
91489     }
91490   }
91491 }
91492
91493
91494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91495   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91496   Dali::Vector2 *arg2 = 0 ;
91497
91498   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91499   arg2 = (Dali::Vector2 *)jarg2;
91500   if (!arg2) {
91501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91502     return ;
91503   }
91504   {
91505     try {
91506       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91507     } catch (std::out_of_range& e) {
91508       {
91509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91510       };
91511     } catch (std::exception& e) {
91512       {
91513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91514       };
91515     } catch (...) {
91516       {
91517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91518       };
91519     }
91520   }
91521 }
91522
91523
91524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91525   void * jresult ;
91526   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91527
91528   {
91529     try {
91530       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91531     } catch (std::out_of_range& e) {
91532       {
91533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91534       };
91535     } catch (std::exception& e) {
91536       {
91537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91538       };
91539     } catch (...) {
91540       {
91541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91542       };
91543     }
91544   }
91545   jresult = (void *)result;
91546   return jresult;
91547 }
91548
91549
91550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91551   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91552
91553   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91554   {
91555     try {
91556       delete arg1;
91557     } catch (std::out_of_range& e) {
91558       {
91559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91560       };
91561     } catch (std::exception& e) {
91562       {
91563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91564       };
91565     } catch (...) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91568       };
91569     }
91570   }
91571 }
91572
91573
91574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91575   unsigned int jresult ;
91576   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91577   bool result;
91578
91579   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91580   {
91581     try {
91582       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91583     } catch (std::out_of_range& e) {
91584       {
91585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91586       };
91587     } catch (std::exception& e) {
91588       {
91589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91590       };
91591     } catch (...) {
91592       {
91593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91594       };
91595     }
91596   }
91597   jresult = result;
91598   return jresult;
91599 }
91600
91601
91602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91603   unsigned long jresult ;
91604   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91605   std::size_t result;
91606
91607   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91608   {
91609     try {
91610       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91611     } catch (std::out_of_range& e) {
91612       {
91613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91614       };
91615     } catch (std::exception& e) {
91616       {
91617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91618       };
91619     } catch (...) {
91620       {
91621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91622       };
91623     }
91624   }
91625   jresult = (unsigned long)result;
91626   return jresult;
91627 }
91628
91629
91630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91631   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91632   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91633
91634   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91635   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91636   {
91637     try {
91638       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91639     } catch (std::out_of_range& e) {
91640       {
91641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91642       };
91643     } catch (std::exception& e) {
91644       {
91645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91646       };
91647     } catch (...) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91650       };
91651     }
91652   }
91653 }
91654
91655
91656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91657   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91658   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91659
91660   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91661   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91662   {
91663     try {
91664       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91665     } catch (std::out_of_range& e) {
91666       {
91667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91668       };
91669     } catch (std::exception& e) {
91670       {
91671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91672       };
91673     } catch (...) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91676       };
91677     }
91678   }
91679 }
91680
91681
91682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91683   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91684   Dali::Toolkit::TextEditor arg2 ;
91685   Dali::Toolkit::TextEditor *argp2 ;
91686
91687   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91688   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91689   if (!argp2) {
91690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91691     return ;
91692   }
91693   arg2 = *argp2;
91694   {
91695     try {
91696       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91697     } catch (std::out_of_range& e) {
91698       {
91699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91700       };
91701     } catch (std::exception& e) {
91702       {
91703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91704       };
91705     } catch (...) {
91706       {
91707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91708       };
91709     }
91710   }
91711 }
91712
91713
91714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91715   void * jresult ;
91716   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91717
91718   {
91719     try {
91720       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91721     } catch (std::out_of_range& e) {
91722       {
91723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91724       };
91725     } catch (std::exception& e) {
91726       {
91727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (...) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91732       };
91733     }
91734   }
91735   jresult = (void *)result;
91736   return jresult;
91737 }
91738
91739
91740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91741   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91742
91743   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91744   {
91745     try {
91746       delete arg1;
91747     } catch (std::out_of_range& e) {
91748       {
91749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91750       };
91751     } catch (std::exception& e) {
91752       {
91753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91754       };
91755     } catch (...) {
91756       {
91757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91758       };
91759     }
91760   }
91761 }
91762
91763
91764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91765   unsigned int jresult ;
91766   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91767   bool result;
91768
91769   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91770   {
91771     try {
91772       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91773     } catch (std::out_of_range& e) {
91774       {
91775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91776       };
91777     } catch (std::exception& e) {
91778       {
91779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91780       };
91781     } catch (...) {
91782       {
91783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91784       };
91785     }
91786   }
91787   jresult = result;
91788   return jresult;
91789 }
91790
91791
91792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91793   unsigned long jresult ;
91794   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91795   std::size_t result;
91796
91797   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91798   {
91799     try {
91800       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91801     } catch (std::out_of_range& e) {
91802       {
91803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91804       };
91805     } catch (std::exception& e) {
91806       {
91807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91808       };
91809     } catch (...) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91812       };
91813     }
91814   }
91815   jresult = (unsigned long)result;
91816   return jresult;
91817 }
91818
91819
91820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91821   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91822   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91823
91824   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91825   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91826   {
91827     try {
91828       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91829     } catch (std::out_of_range& e) {
91830       {
91831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91832       };
91833     } catch (std::exception& e) {
91834       {
91835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91836       };
91837     } catch (...) {
91838       {
91839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91840       };
91841     }
91842   }
91843 }
91844
91845
91846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91847   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91848   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91849
91850   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91851   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91852   {
91853     try {
91854       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91855     } catch (std::out_of_range& e) {
91856       {
91857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91858       };
91859     } catch (std::exception& e) {
91860       {
91861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91862       };
91863     } catch (...) {
91864       {
91865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91866       };
91867     }
91868   }
91869 }
91870
91871
91872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91873   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91874   Dali::Toolkit::TextField arg2 ;
91875   Dali::Toolkit::TextField *argp2 ;
91876
91877   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91878   argp2 = (Dali::Toolkit::TextField *)jarg2;
91879   if (!argp2) {
91880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91881     return ;
91882   }
91883   arg2 = *argp2;
91884   {
91885     try {
91886       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91887     } catch (std::out_of_range& e) {
91888       {
91889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91890       };
91891     } catch (std::exception& e) {
91892       {
91893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91894       };
91895     } catch (...) {
91896       {
91897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91898       };
91899     }
91900   }
91901 }
91902
91903
91904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91905   void * jresult ;
91906   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91907
91908   {
91909     try {
91910       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91911     } catch (std::out_of_range& e) {
91912       {
91913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91914       };
91915     } catch (std::exception& e) {
91916       {
91917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91918       };
91919     } catch (...) {
91920       {
91921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91922       };
91923     }
91924   }
91925   jresult = (void *)result;
91926   return jresult;
91927 }
91928
91929
91930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91931   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91932
91933   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91934   {
91935     try {
91936       delete arg1;
91937     } catch (std::out_of_range& e) {
91938       {
91939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91940       };
91941     } catch (std::exception& e) {
91942       {
91943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91944       };
91945     } catch (...) {
91946       {
91947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91948       };
91949     }
91950   }
91951 }
91952
91953
91954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91955   unsigned int jresult ;
91956   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91957   bool result;
91958
91959   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91960   {
91961     try {
91962       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);
91963     } catch (std::out_of_range& e) {
91964       {
91965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91966       };
91967     } catch (std::exception& e) {
91968       {
91969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91970       };
91971     } catch (...) {
91972       {
91973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91974       };
91975     }
91976   }
91977   jresult = result;
91978   return jresult;
91979 }
91980
91981
91982 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91983   unsigned long jresult ;
91984   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91985   std::size_t result;
91986
91987   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91988   {
91989     try {
91990       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);
91991     } catch (std::out_of_range& e) {
91992       {
91993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91994       };
91995     } catch (std::exception& e) {
91996       {
91997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (...) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92002       };
92003     }
92004   }
92005   jresult = (unsigned long)result;
92006   return jresult;
92007 }
92008
92009
92010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92011   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92012   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92013
92014   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92015   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92016   {
92017     try {
92018       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92019     } catch (std::out_of_range& e) {
92020       {
92021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92022       };
92023     } catch (std::exception& e) {
92024       {
92025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92026       };
92027     } catch (...) {
92028       {
92029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92030       };
92031     }
92032   }
92033 }
92034
92035
92036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92037   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92038   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92039
92040   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92041   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92042   {
92043     try {
92044       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92045     } catch (std::out_of_range& e) {
92046       {
92047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92048       };
92049     } catch (std::exception& e) {
92050       {
92051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92052       };
92053     } catch (...) {
92054       {
92055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92056       };
92057     }
92058   }
92059 }
92060
92061
92062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92063   unsigned int jresult ;
92064   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92065   Dali::Toolkit::Control arg2 ;
92066   Dali::KeyEvent *arg3 = 0 ;
92067   Dali::Toolkit::Control *argp2 ;
92068   bool result;
92069
92070   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92071   argp2 = (Dali::Toolkit::Control *)jarg2;
92072   if (!argp2) {
92073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92074     return 0;
92075   }
92076   arg2 = *argp2;
92077   arg3 = (Dali::KeyEvent *)jarg3;
92078   if (!arg3) {
92079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92080     return 0;
92081   }
92082   {
92083     try {
92084       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);
92085     } catch (std::out_of_range& e) {
92086       {
92087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92088       };
92089     } catch (std::exception& e) {
92090       {
92091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92092       };
92093     } catch (...) {
92094       {
92095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92096       };
92097     }
92098   }
92099   jresult = result;
92100   return jresult;
92101 }
92102
92103
92104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92105   void * jresult ;
92106   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92107
92108   {
92109     try {
92110       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92111     } catch (std::out_of_range& e) {
92112       {
92113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92114       };
92115     } catch (std::exception& e) {
92116       {
92117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92118       };
92119     } catch (...) {
92120       {
92121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92122       };
92123     }
92124   }
92125   jresult = (void *)result;
92126   return jresult;
92127 }
92128
92129
92130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92131   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92132
92133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92134   {
92135     try {
92136       delete arg1;
92137     } catch (std::out_of_range& e) {
92138       {
92139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92140       };
92141     } catch (std::exception& e) {
92142       {
92143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92144       };
92145     } catch (...) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92148       };
92149     }
92150   }
92151 }
92152
92153
92154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92155   unsigned int jresult ;
92156   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92157   bool result;
92158
92159   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92160   {
92161     try {
92162       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92163     } catch (std::out_of_range& e) {
92164       {
92165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92166       };
92167     } catch (std::exception& e) {
92168       {
92169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92170       };
92171     } catch (...) {
92172       {
92173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92174       };
92175     }
92176   }
92177   jresult = result;
92178   return jresult;
92179 }
92180
92181
92182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92183   unsigned long jresult ;
92184   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92185   std::size_t result;
92186
92187   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92188   {
92189     try {
92190       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92191     } catch (std::out_of_range& e) {
92192       {
92193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92194       };
92195     } catch (std::exception& e) {
92196       {
92197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92198       };
92199     } catch (...) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92202       };
92203     }
92204   }
92205   jresult = (unsigned long)result;
92206   return jresult;
92207 }
92208
92209
92210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92211   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92212   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92213
92214   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92215   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92216   {
92217     try {
92218       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92219     } catch (std::out_of_range& e) {
92220       {
92221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92222       };
92223     } catch (std::exception& e) {
92224       {
92225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92226       };
92227     } catch (...) {
92228       {
92229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92230       };
92231     }
92232   }
92233 }
92234
92235
92236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92237   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92238   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92239
92240   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92241   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92242   {
92243     try {
92244       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92245     } catch (std::out_of_range& e) {
92246       {
92247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92248       };
92249     } catch (std::exception& e) {
92250       {
92251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92252       };
92253     } catch (...) {
92254       {
92255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92256       };
92257     }
92258   }
92259 }
92260
92261
92262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92263   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92264   Dali::Toolkit::Control arg2 ;
92265   Dali::Toolkit::Control *argp2 ;
92266
92267   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92268   argp2 = (Dali::Toolkit::Control *)jarg2;
92269   if (!argp2) {
92270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92271     return ;
92272   }
92273   arg2 = *argp2;
92274   {
92275     try {
92276       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92277     } catch (std::out_of_range& e) {
92278       {
92279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92280       };
92281     } catch (std::exception& e) {
92282       {
92283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92284       };
92285     } catch (...) {
92286       {
92287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92288       };
92289     }
92290   }
92291 }
92292
92293
92294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92295   void * jresult ;
92296   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92297
92298   {
92299     try {
92300       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92301     } catch (std::out_of_range& e) {
92302       {
92303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92304       };
92305     } catch (std::exception& e) {
92306       {
92307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92308       };
92309     } catch (...) {
92310       {
92311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92312       };
92313     }
92314   }
92315   jresult = (void *)result;
92316   return jresult;
92317 }
92318
92319
92320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92321   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92322
92323   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92324   {
92325     try {
92326       delete arg1;
92327     } catch (std::out_of_range& e) {
92328       {
92329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92330       };
92331     } catch (std::exception& e) {
92332       {
92333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92334       };
92335     } catch (...) {
92336       {
92337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92338       };
92339     }
92340   }
92341 }
92342
92343
92344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92345   unsigned int jresult ;
92346   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92347   bool result;
92348
92349   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92350   {
92351     try {
92352       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92360       };
92361     } catch (...) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92364       };
92365     }
92366   }
92367   jresult = result;
92368   return jresult;
92369 }
92370
92371
92372 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92373   unsigned long jresult ;
92374   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92375   std::size_t result;
92376
92377   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92378   {
92379     try {
92380       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92381     } catch (std::out_of_range& e) {
92382       {
92383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92384       };
92385     } catch (std::exception& e) {
92386       {
92387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92388       };
92389     } catch (...) {
92390       {
92391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92392       };
92393     }
92394   }
92395   jresult = (unsigned long)result;
92396   return jresult;
92397 }
92398
92399
92400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92401   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92402   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92403
92404   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92405   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92406   {
92407     try {
92408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92409     } catch (std::out_of_range& e) {
92410       {
92411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92412       };
92413     } catch (std::exception& e) {
92414       {
92415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92416       };
92417     } catch (...) {
92418       {
92419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92420       };
92421     }
92422   }
92423 }
92424
92425
92426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92427   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92428   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92429
92430   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92431   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92432   {
92433     try {
92434       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92435     } catch (std::out_of_range& e) {
92436       {
92437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92438       };
92439     } catch (std::exception& e) {
92440       {
92441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92442       };
92443     } catch (...) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92446       };
92447     }
92448   }
92449 }
92450
92451
92452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92453   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92454   Dali::Toolkit::VideoView *arg2 = 0 ;
92455
92456   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92457   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92458   if (!arg2) {
92459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92460     return ;
92461   }
92462   {
92463     try {
92464       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92465     } catch (std::out_of_range& e) {
92466       {
92467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92468       };
92469     } catch (std::exception& e) {
92470       {
92471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92472       };
92473     } catch (...) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92476       };
92477     }
92478   }
92479 }
92480
92481
92482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92483   void * jresult ;
92484   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92485
92486   {
92487     try {
92488       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92489     } catch (std::out_of_range& e) {
92490       {
92491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92492       };
92493     } catch (std::exception& e) {
92494       {
92495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92496       };
92497     } catch (...) {
92498       {
92499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92500       };
92501     }
92502   }
92503   jresult = (void *)result;
92504   return jresult;
92505 }
92506
92507
92508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92509   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92510
92511   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92512   {
92513     try {
92514       delete arg1;
92515     } catch (std::out_of_range& e) {
92516       {
92517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92518       };
92519     } catch (std::exception& e) {
92520       {
92521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92522       };
92523     } catch (...) {
92524       {
92525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92526       };
92527     }
92528   }
92529 }
92530
92531
92532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92533   unsigned int jresult ;
92534   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92535   bool result;
92536
92537   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92538   {
92539     try {
92540       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92541     } catch (std::out_of_range& e) {
92542       {
92543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92544       };
92545     } catch (std::exception& e) {
92546       {
92547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92548       };
92549     } catch (...) {
92550       {
92551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92552       };
92553     }
92554   }
92555   jresult = result;
92556   return jresult;
92557 }
92558
92559
92560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92561   unsigned long jresult ;
92562   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92563   std::size_t result;
92564
92565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92566   {
92567     try {
92568       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92569     } catch (std::out_of_range& e) {
92570       {
92571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92572       };
92573     } catch (std::exception& e) {
92574       {
92575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92576       };
92577     } catch (...) {
92578       {
92579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92580       };
92581     }
92582   }
92583   jresult = (unsigned long)result;
92584   return jresult;
92585 }
92586
92587
92588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92589   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92590   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92591
92592   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92593   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92594   {
92595     try {
92596       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92597     } catch (std::out_of_range& e) {
92598       {
92599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92600       };
92601     } catch (std::exception& e) {
92602       {
92603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92604       };
92605     } catch (...) {
92606       {
92607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92608       };
92609     }
92610   }
92611 }
92612
92613
92614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92615   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92616   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92617
92618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92619   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92620   {
92621     try {
92622       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92623     } catch (std::out_of_range& e) {
92624       {
92625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92626       };
92627     } catch (std::exception& e) {
92628       {
92629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92630       };
92631     } catch (...) {
92632       {
92633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92634       };
92635     }
92636   }
92637 }
92638
92639
92640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92641   unsigned int jresult ;
92642   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92643   Dali::Toolkit::Slider arg2 ;
92644   float arg3 ;
92645   Dali::Toolkit::Slider *argp2 ;
92646   bool result;
92647
92648   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92649   argp2 = (Dali::Toolkit::Slider *)jarg2;
92650   if (!argp2) {
92651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92652     return 0;
92653   }
92654   arg2 = *argp2;
92655   arg3 = (float)jarg3;
92656   {
92657     try {
92658       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92659     } catch (std::out_of_range& e) {
92660       {
92661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92662       };
92663     } catch (std::exception& e) {
92664       {
92665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92666       };
92667     } catch (...) {
92668       {
92669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92670       };
92671     }
92672   }
92673   jresult = result;
92674   return jresult;
92675 }
92676
92677
92678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92679   void * jresult ;
92680   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92681
92682   {
92683     try {
92684       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92685     } catch (std::out_of_range& e) {
92686       {
92687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92688       };
92689     } catch (std::exception& e) {
92690       {
92691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92692       };
92693     } catch (...) {
92694       {
92695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92696       };
92697     }
92698   }
92699   jresult = (void *)result;
92700   return jresult;
92701 }
92702
92703
92704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92705   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92706
92707   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92708   {
92709     try {
92710       delete arg1;
92711     } catch (std::out_of_range& e) {
92712       {
92713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92714       };
92715     } catch (std::exception& e) {
92716       {
92717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92718       };
92719     } catch (...) {
92720       {
92721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92722       };
92723     }
92724   }
92725 }
92726
92727
92728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92729   unsigned int jresult ;
92730   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92731   bool result;
92732
92733   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92734   {
92735     try {
92736       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92737     } catch (std::out_of_range& e) {
92738       {
92739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92740       };
92741     } catch (std::exception& e) {
92742       {
92743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92744       };
92745     } catch (...) {
92746       {
92747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92748       };
92749     }
92750   }
92751   jresult = result;
92752   return jresult;
92753 }
92754
92755
92756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92757   unsigned long jresult ;
92758   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92759   std::size_t result;
92760
92761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92762   {
92763     try {
92764       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92765     } catch (std::out_of_range& e) {
92766       {
92767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92768       };
92769     } catch (std::exception& e) {
92770       {
92771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92772       };
92773     } catch (...) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92776       };
92777     }
92778   }
92779   jresult = (unsigned long)result;
92780   return jresult;
92781 }
92782
92783
92784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92785   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92786   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92787
92788   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92789   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92790   {
92791     try {
92792       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92793     } catch (std::out_of_range& e) {
92794       {
92795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92796       };
92797     } catch (std::exception& e) {
92798       {
92799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92800       };
92801     } catch (...) {
92802       {
92803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92804       };
92805     }
92806   }
92807 }
92808
92809
92810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92811   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92812   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92813
92814   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92815   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92816   {
92817     try {
92818       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92819     } catch (std::out_of_range& e) {
92820       {
92821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92822       };
92823     } catch (std::exception& e) {
92824       {
92825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92826       };
92827     } catch (...) {
92828       {
92829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92830       };
92831     }
92832   }
92833 }
92834
92835
92836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92837   unsigned int jresult ;
92838   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92839   Dali::Toolkit::Slider arg2 ;
92840   int arg3 ;
92841   Dali::Toolkit::Slider *argp2 ;
92842   bool result;
92843
92844   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92845   argp2 = (Dali::Toolkit::Slider *)jarg2;
92846   if (!argp2) {
92847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92848     return 0;
92849   }
92850   arg2 = *argp2;
92851   arg3 = (int)jarg3;
92852   {
92853     try {
92854       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92855     } catch (std::out_of_range& e) {
92856       {
92857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92858       };
92859     } catch (std::exception& e) {
92860       {
92861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92862       };
92863     } catch (...) {
92864       {
92865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92866       };
92867     }
92868   }
92869   jresult = result;
92870   return jresult;
92871 }
92872
92873
92874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92875   void * jresult ;
92876   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92877
92878   {
92879     try {
92880       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92881     } catch (std::out_of_range& e) {
92882       {
92883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92884       };
92885     } catch (std::exception& e) {
92886       {
92887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92888       };
92889     } catch (...) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92892       };
92893     }
92894   }
92895   jresult = (void *)result;
92896   return jresult;
92897 }
92898
92899
92900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92901   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92902
92903   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92904   {
92905     try {
92906       delete arg1;
92907     } catch (std::out_of_range& e) {
92908       {
92909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92910       };
92911     } catch (std::exception& e) {
92912       {
92913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92914       };
92915     } catch (...) {
92916       {
92917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92918       };
92919     }
92920   }
92921 }
92922
92923
92924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92925   void * jresult ;
92926   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92927
92928   {
92929     try {
92930       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92931     } catch (std::out_of_range& e) {
92932       {
92933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92934       };
92935     } catch (std::exception& e) {
92936       {
92937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (...) {
92940       {
92941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92942       };
92943     }
92944   }
92945   jresult = (void *)result;
92946   return jresult;
92947 }
92948
92949
92950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92951   void * jresult ;
92952   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92954
92955   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92956   {
92957     try {
92958       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92959     } catch (std::out_of_range& e) {
92960       {
92961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92962       };
92963     } catch (std::exception& e) {
92964       {
92965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92966       };
92967     } catch (...) {
92968       {
92969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92970       };
92971     }
92972   }
92973   jresult = (void *)result;
92974   return jresult;
92975 }
92976
92977
92978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92979   void * jresult ;
92980   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92981   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92982
92983   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92984   if (!arg1) {
92985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92986     return 0;
92987   }
92988   {
92989     try {
92990       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92991     } catch (std::out_of_range& e) {
92992       {
92993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92994       };
92995     } catch (std::exception& e) {
92996       {
92997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92998       };
92999     } catch (...) {
93000       {
93001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93002       };
93003     }
93004   }
93005   jresult = (void *)result;
93006   return jresult;
93007 }
93008
93009
93010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93011   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93012
93013   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93014   {
93015     try {
93016       delete arg1;
93017     } catch (std::out_of_range& e) {
93018       {
93019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93020       };
93021     } catch (std::exception& e) {
93022       {
93023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93024       };
93025     } catch (...) {
93026       {
93027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93028       };
93029     }
93030   }
93031 }
93032
93033
93034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93035   void * jresult ;
93036   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93037   Dali::Toolkit::Ruler *result = 0 ;
93038
93039   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93040   {
93041     try {
93042       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93043     } catch (std::out_of_range& e) {
93044       {
93045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93046       };
93047     } catch (std::exception& e) {
93048       {
93049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93050       };
93051     } catch (...) {
93052       {
93053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93054       };
93055     }
93056   }
93057   jresult = (void *)result;
93058   return jresult;
93059 }
93060
93061
93062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93063   void * jresult ;
93064   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93065   Dali::Toolkit::Ruler *result = 0 ;
93066
93067   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93068   {
93069     try {
93070       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93071     } catch (std::out_of_range& e) {
93072       {
93073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93074       };
93075     } catch (std::exception& e) {
93076       {
93077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93078       };
93079     } catch (...) {
93080       {
93081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93082       };
93083     }
93084   }
93085   jresult = (void *)result;
93086   return jresult;
93087 }
93088
93089
93090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93091   void * jresult ;
93092   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93093   Dali::Toolkit::Ruler *result = 0 ;
93094
93095   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93096   {
93097     try {
93098       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93099     } catch (std::out_of_range& e) {
93100       {
93101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93102       };
93103     } catch (std::exception& e) {
93104       {
93105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93106       };
93107     } catch (...) {
93108       {
93109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93110       };
93111     }
93112   }
93113   jresult = (void *)result;
93114   return jresult;
93115 }
93116
93117
93118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93119   void * jresult ;
93120   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93121   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93123
93124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93125   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93126   if (!arg2) {
93127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93128     return 0;
93129   }
93130   {
93131     try {
93132       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93133     } catch (std::out_of_range& e) {
93134       {
93135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93136       };
93137     } catch (std::exception& e) {
93138       {
93139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93140       };
93141     } catch (...) {
93142       {
93143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93144       };
93145     }
93146   }
93147   jresult = (void *)result;
93148   return jresult;
93149 }
93150
93151
93152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93153   void * jresult ;
93154   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93155   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93157
93158   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93159   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93160   {
93161     try {
93162       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93163     } catch (std::out_of_range& e) {
93164       {
93165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93166       };
93167     } catch (std::exception& e) {
93168       {
93169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93170       };
93171     } catch (...) {
93172       {
93173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93174       };
93175     }
93176   }
93177   jresult = (void *)result;
93178   return jresult;
93179 }
93180
93181
93182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93184
93185   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93186   {
93187     try {
93188       (arg1)->Reset();
93189     } catch (std::out_of_range& e) {
93190       {
93191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93192       };
93193     } catch (std::exception& e) {
93194       {
93195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93196       };
93197     } catch (...) {
93198       {
93199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93200       };
93201     }
93202   }
93203 }
93204
93205
93206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93207   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93208   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93209
93210   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93211   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93212   {
93213     try {
93214       (arg1)->Reset(arg2);
93215     } catch (std::out_of_range& e) {
93216       {
93217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93218       };
93219     } catch (std::exception& e) {
93220       {
93221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93222       };
93223     } catch (...) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93226       };
93227     }
93228   }
93229 }
93230
93231
93232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93233   void * jresult ;
93234   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93235   Dali::Toolkit::Ruler *result = 0 ;
93236
93237   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93238   {
93239     try {
93240       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93241     } catch (std::out_of_range& e) {
93242       {
93243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93244       };
93245     } catch (std::exception& e) {
93246       {
93247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93248       };
93249     } catch (...) {
93250       {
93251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93252       };
93253     }
93254   }
93255   jresult = (void *)result;
93256   return jresult;
93257 }
93258
93259
93260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93261   float jresult ;
93262   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93263   float arg2 ;
93264   float arg3 ;
93265   float result;
93266
93267   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93268   arg2 = (float)jarg2;
93269   arg3 = (float)jarg3;
93270   {
93271     try {
93272       result = (float)(*arg1)->Snap(arg2,arg3);
93273     } catch (std::out_of_range& e) {
93274       {
93275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93276       };
93277     } catch (std::exception& e) {
93278       {
93279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93280       };
93281     } catch (...) {
93282       {
93283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93284       };
93285     }
93286   }
93287   jresult = result;
93288   return jresult;
93289 }
93290
93291
93292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93293   float jresult ;
93294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93295   float arg2 ;
93296   float result;
93297
93298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93299   arg2 = (float)jarg2;
93300   {
93301     try {
93302       result = (float)(*arg1)->Snap(arg2);
93303     } catch (std::out_of_range& e) {
93304       {
93305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93306       };
93307     } catch (std::exception& e) {
93308       {
93309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93310       };
93311     } catch (...) {
93312       {
93313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93314       };
93315     }
93316   }
93317   jresult = result;
93318   return jresult;
93319 }
93320
93321
93322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93323   float jresult ;
93324   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93325   unsigned int arg2 ;
93326   unsigned int *arg3 = 0 ;
93327   bool arg4 ;
93328   float result;
93329
93330   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93331   arg2 = (unsigned int)jarg2;
93332   arg3 = (unsigned int *)jarg3;
93333   arg4 = jarg4 ? true : false;
93334   {
93335     try {
93336       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93337     } catch (std::out_of_range& e) {
93338       {
93339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93340       };
93341     } catch (std::exception& e) {
93342       {
93343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93344       };
93345     } catch (...) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93348       };
93349     }
93350   }
93351   jresult = result;
93352   return jresult;
93353 }
93354
93355
93356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93357   unsigned int jresult ;
93358   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93359   float arg2 ;
93360   bool arg3 ;
93361   unsigned int result;
93362
93363   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93364   arg2 = (float)jarg2;
93365   arg3 = jarg3 ? true : false;
93366   {
93367     try {
93368       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93369     } catch (std::out_of_range& e) {
93370       {
93371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93372       };
93373     } catch (std::exception& e) {
93374       {
93375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93376       };
93377     } catch (...) {
93378       {
93379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93380       };
93381     }
93382   }
93383   jresult = result;
93384   return jresult;
93385 }
93386
93387
93388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93389   unsigned int jresult ;
93390   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93391   unsigned int result;
93392
93393   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93394   {
93395     try {
93396       result = (unsigned int)(*arg1)->GetTotalPages();
93397     } catch (std::out_of_range& e) {
93398       {
93399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93400       };
93401     } catch (std::exception& e) {
93402       {
93403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93404       };
93405     } catch (...) {
93406       {
93407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93408       };
93409     }
93410   }
93411   jresult = result;
93412   return jresult;
93413 }
93414
93415
93416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93417   int jresult ;
93418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93419   Dali::Toolkit::Ruler::RulerType result;
93420
93421   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93422   {
93423     try {
93424       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93425     } catch (std::out_of_range& e) {
93426       {
93427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93428       };
93429     } catch (std::exception& e) {
93430       {
93431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93432       };
93433     } catch (...) {
93434       {
93435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93436       };
93437     }
93438   }
93439   jresult = (int)result;
93440   return jresult;
93441 }
93442
93443
93444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93445   unsigned int jresult ;
93446   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93447   bool result;
93448
93449   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93450   {
93451     try {
93452       result = (bool)(*arg1)->IsEnabled();
93453     } catch (std::out_of_range& e) {
93454       {
93455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93456       };
93457     } catch (std::exception& e) {
93458       {
93459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93460       };
93461     } catch (...) {
93462       {
93463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93464       };
93465     }
93466   }
93467   jresult = result;
93468   return jresult;
93469 }
93470
93471
93472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93473   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93474
93475   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93476   {
93477     try {
93478       (*arg1)->Enable();
93479     } catch (std::out_of_range& e) {
93480       {
93481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93482       };
93483     } catch (std::exception& e) {
93484       {
93485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93486       };
93487     } catch (...) {
93488       {
93489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93490       };
93491     }
93492   }
93493 }
93494
93495
93496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93498
93499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93500   {
93501     try {
93502       (*arg1)->Disable();
93503     } catch (std::out_of_range& e) {
93504       {
93505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93506       };
93507     } catch (std::exception& e) {
93508       {
93509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93510       };
93511     } catch (...) {
93512       {
93513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93514       };
93515     }
93516   }
93517 }
93518
93519
93520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93521   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93522   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93523   Dali::Toolkit::RulerDomain *argp2 ;
93524
93525   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93526   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93527   if (!argp2) {
93528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93529     return ;
93530   }
93531   arg2 = *argp2;
93532   {
93533     try {
93534       (*arg1)->SetDomain(arg2);
93535     } catch (std::out_of_range& e) {
93536       {
93537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93538       };
93539     } catch (std::exception& e) {
93540       {
93541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93542       };
93543     } catch (...) {
93544       {
93545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93546       };
93547     }
93548   }
93549 }
93550
93551
93552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93553   void * jresult ;
93554   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93555   Dali::Toolkit::RulerDomain *result = 0 ;
93556
93557   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93558   {
93559     try {
93560       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93561     } catch (std::out_of_range& e) {
93562       {
93563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93564       };
93565     } catch (std::exception& e) {
93566       {
93567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93568       };
93569     } catch (...) {
93570       {
93571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93572       };
93573     }
93574   }
93575   jresult = (void *)result;
93576   return jresult;
93577 }
93578
93579
93580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93581   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93582
93583   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93584   {
93585     try {
93586       (*arg1)->DisableDomain();
93587     } catch (std::out_of_range& e) {
93588       {
93589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93590       };
93591     } catch (std::exception& e) {
93592       {
93593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93594       };
93595     } catch (...) {
93596       {
93597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93598       };
93599     }
93600   }
93601 }
93602
93603
93604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93605   float jresult ;
93606   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93607   float arg2 ;
93608   float arg3 ;
93609   float arg4 ;
93610   float result;
93611
93612   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93613   arg2 = (float)jarg2;
93614   arg3 = (float)jarg3;
93615   arg4 = (float)jarg4;
93616   {
93617     try {
93618       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93619     } catch (std::out_of_range& e) {
93620       {
93621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93622       };
93623     } catch (std::exception& e) {
93624       {
93625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93626       };
93627     } catch (...) {
93628       {
93629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93630       };
93631     }
93632   }
93633   jresult = result;
93634   return jresult;
93635 }
93636
93637
93638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93639   float jresult ;
93640   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93641   float arg2 ;
93642   float arg3 ;
93643   float result;
93644
93645   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93646   arg2 = (float)jarg2;
93647   arg3 = (float)jarg3;
93648   {
93649     try {
93650       result = (float)(*arg1)->Clamp(arg2,arg3);
93651     } catch (std::out_of_range& e) {
93652       {
93653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93654       };
93655     } catch (std::exception& e) {
93656       {
93657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93658       };
93659     } catch (...) {
93660       {
93661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93662       };
93663     }
93664   }
93665   jresult = result;
93666   return jresult;
93667 }
93668
93669
93670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93671   float jresult ;
93672   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93673   float arg2 ;
93674   float result;
93675
93676   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93677   arg2 = (float)jarg2;
93678   {
93679     try {
93680       result = (float)(*arg1)->Clamp(arg2);
93681     } catch (std::out_of_range& e) {
93682       {
93683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93684       };
93685     } catch (std::exception& e) {
93686       {
93687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93688       };
93689     } catch (...) {
93690       {
93691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93692       };
93693     }
93694   }
93695   jresult = result;
93696   return jresult;
93697 }
93698
93699
93700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93701   float jresult ;
93702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93703   float arg2 ;
93704   float arg3 ;
93705   float arg4 ;
93706   Dali::Toolkit::ClampState *arg5 = 0 ;
93707   float result;
93708
93709   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93710   arg2 = (float)jarg2;
93711   arg3 = (float)jarg3;
93712   arg4 = (float)jarg4;
93713   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93714   if (!arg5) {
93715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93716     return 0;
93717   }
93718   {
93719     try {
93720       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93721     } catch (std::out_of_range& e) {
93722       {
93723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93724       };
93725     } catch (std::exception& e) {
93726       {
93727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93728       };
93729     } catch (...) {
93730       {
93731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93732       };
93733     }
93734   }
93735   jresult = result;
93736   return jresult;
93737 }
93738
93739
93740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93741   float jresult ;
93742   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93743   float arg2 ;
93744   float arg3 ;
93745   float arg4 ;
93746   float arg5 ;
93747   float result;
93748
93749   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93750   arg2 = (float)jarg2;
93751   arg3 = (float)jarg3;
93752   arg4 = (float)jarg4;
93753   arg5 = (float)jarg5;
93754   {
93755     try {
93756       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93757     } catch (std::out_of_range& e) {
93758       {
93759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93760       };
93761     } catch (std::exception& e) {
93762       {
93763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93764       };
93765     } catch (...) {
93766       {
93767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93768       };
93769     }
93770   }
93771   jresult = result;
93772   return jresult;
93773 }
93774
93775
93776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93777   float jresult ;
93778   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93779   float arg2 ;
93780   float arg3 ;
93781   float arg4 ;
93782   float result;
93783
93784   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93785   arg2 = (float)jarg2;
93786   arg3 = (float)jarg3;
93787   arg4 = (float)jarg4;
93788   {
93789     try {
93790       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93791     } catch (std::out_of_range& e) {
93792       {
93793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93794       };
93795     } catch (std::exception& e) {
93796       {
93797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93798       };
93799     } catch (...) {
93800       {
93801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93802       };
93803     }
93804   }
93805   jresult = result;
93806   return jresult;
93807 }
93808
93809
93810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93811   float jresult ;
93812   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93813   float arg2 ;
93814   float arg3 ;
93815   float result;
93816
93817   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93818   arg2 = (float)jarg2;
93819   arg3 = (float)jarg3;
93820   {
93821     try {
93822       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93823     } catch (std::out_of_range& e) {
93824       {
93825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93826       };
93827     } catch (std::exception& e) {
93828       {
93829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93830       };
93831     } catch (...) {
93832       {
93833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93834       };
93835     }
93836   }
93837   jresult = result;
93838   return jresult;
93839 }
93840
93841
93842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93843   float jresult ;
93844   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93845   float arg2 ;
93846   float result;
93847
93848   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93849   arg2 = (float)jarg2;
93850   {
93851     try {
93852       result = (float)(*arg1)->SnapAndClamp(arg2);
93853     } catch (std::out_of_range& e) {
93854       {
93855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93856       };
93857     } catch (std::exception& e) {
93858       {
93859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93860       };
93861     } catch (...) {
93862       {
93863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93864       };
93865     }
93866   }
93867   jresult = result;
93868   return jresult;
93869 }
93870
93871
93872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93873   float jresult ;
93874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93875   float arg2 ;
93876   float arg3 ;
93877   float arg4 ;
93878   float arg5 ;
93879   Dali::Toolkit::ClampState *arg6 = 0 ;
93880   float result;
93881
93882   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93883   arg2 = (float)jarg2;
93884   arg3 = (float)jarg3;
93885   arg4 = (float)jarg4;
93886   arg5 = (float)jarg5;
93887   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93888   if (!arg6) {
93889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93890     return 0;
93891   }
93892   {
93893     try {
93894       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93895     } catch (std::out_of_range& e) {
93896       {
93897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93898       };
93899     } catch (std::exception& e) {
93900       {
93901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93902       };
93903     } catch (...) {
93904       {
93905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93906       };
93907     }
93908   }
93909   jresult = result;
93910   return jresult;
93911 }
93912
93913
93914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93915   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93916
93917   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93918   {
93919     try {
93920       (*arg1)->Reference();
93921     } catch (std::out_of_range& e) {
93922       {
93923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93924       };
93925     } catch (std::exception& e) {
93926       {
93927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93928       };
93929     } catch (...) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93932       };
93933     }
93934   }
93935 }
93936
93937
93938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93939   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93940
93941   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93942   {
93943     try {
93944       (*arg1)->Unreference();
93945     } catch (std::out_of_range& e) {
93946       {
93947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93948       };
93949     } catch (std::exception& e) {
93950       {
93951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93952       };
93953     } catch (...) {
93954       {
93955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93956       };
93957     }
93958   }
93959 }
93960
93961
93962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93963   int jresult ;
93964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93965   int result;
93966
93967   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93968   {
93969     try {
93970       result = (int)(*arg1)->ReferenceCount();
93971     } catch (std::out_of_range& e) {
93972       {
93973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93974       };
93975     } catch (std::exception& e) {
93976       {
93977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93978       };
93979     } catch (...) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93982       };
93983     }
93984   }
93985   jresult = result;
93986   return jresult;
93987 }
93988
93989
93990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
93991   unsigned int jresult ;
93992   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93993   bool result;
93994
93995   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93996   {
93997     try {
93998       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93999     } catch (std::out_of_range& e) {
94000       {
94001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94002       };
94003     } catch (std::exception& e) {
94004       {
94005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94006       };
94007     } catch (...) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94010       };
94011     }
94012   }
94013   jresult = result;
94014   return jresult;
94015 }
94016
94017
94018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94019   unsigned long jresult ;
94020   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94021   std::size_t result;
94022
94023   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94024   {
94025     try {
94026       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94027     } catch (std::out_of_range& e) {
94028       {
94029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94030       };
94031     } catch (std::exception& e) {
94032       {
94033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94034       };
94035     } catch (...) {
94036       {
94037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94038       };
94039     }
94040   }
94041   jresult = (unsigned long)result;
94042   return jresult;
94043 }
94044
94045
94046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
94047   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94048   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94049
94050   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94051   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94052   {
94053     try {
94054       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94055     } catch (std::out_of_range& e) {
94056       {
94057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94058       };
94059     } catch (std::exception& e) {
94060       {
94061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94062       };
94063     } catch (...) {
94064       {
94065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94066       };
94067     }
94068   }
94069 }
94070
94071
94072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
94073   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94074   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94075
94076   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94077   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94078   {
94079     try {
94080       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94081     } catch (std::out_of_range& e) {
94082       {
94083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94084       };
94085     } catch (std::exception& e) {
94086       {
94087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (...) {
94090       {
94091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94092       };
94093     }
94094   }
94095 }
94096
94097
94098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
94099   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94100   Dali::Toolkit::Control arg2 ;
94101   Dali::Toolkit::Control *argp2 ;
94102
94103   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94104   argp2 = (Dali::Toolkit::Control *)jarg2;
94105   if (!argp2) {
94106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94107     return ;
94108   }
94109   arg2 = *argp2;
94110   {
94111     try {
94112       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94113     } catch (std::out_of_range& e) {
94114       {
94115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94116       };
94117     } catch (std::exception& e) {
94118       {
94119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94120       };
94121     } catch (...) {
94122       {
94123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94124       };
94125     }
94126   }
94127 }
94128
94129
94130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94131   void * jresult ;
94132   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94133
94134   {
94135     try {
94136       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94137     } catch (std::out_of_range& e) {
94138       {
94139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94140       };
94141     } catch (std::exception& e) {
94142       {
94143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94144       };
94145     } catch (...) {
94146       {
94147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94148       };
94149     }
94150   }
94151   jresult = (void *)result;
94152   return jresult;
94153 }
94154
94155
94156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94157   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94158
94159   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94160   {
94161     try {
94162       delete arg1;
94163     } catch (std::out_of_range& e) {
94164       {
94165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94166       };
94167     } catch (std::exception& e) {
94168       {
94169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94170       };
94171     } catch (...) {
94172       {
94173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94174       };
94175     }
94176   }
94177 }
94178
94179 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94180     return (Dali::RefObject *)jarg1;
94181 }
94182
94183 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94184     return (Dali::SignalObserver *)jarg1;
94185 }
94186
94187 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94188     return (Dali::ConnectionTrackerInterface *)jarg1;
94189 }
94190
94191 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94192     return (Dali::BaseHandle *)jarg1;
94193 }
94194
94195 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94196     return (Dali::BaseHandle *)jarg1;
94197 }
94198
94199 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94200     return (Dali::BaseHandle *)jarg1;
94201 }
94202
94203 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94204     return (Dali::BaseHandle *)jarg1;
94205 }
94206
94207 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94208     return (Dali::BaseHandle *)jarg1;
94209 }
94210
94211 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94212     return (Dali::BaseHandle *)jarg1;
94213 }
94214
94215 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94216     return (Dali::BaseHandle *)jarg1;
94217 }
94218
94219 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94220     return (Dali::BaseHandle *)jarg1;
94221 }
94222
94223 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94224     return (Dali::BaseHandle *)jarg1;
94225 }
94226
94227 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94228     return (Dali::BaseHandle *)jarg1;
94229 }
94230
94231 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94232     return (Dali::BaseHandle *)jarg1;
94233 }
94234
94235 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94236     return (Dali::BaseHandle *)jarg1;
94237 }
94238
94239 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94240     return (Dali::BaseHandle *)jarg1;
94241 }
94242
94243 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94244     return (Dali::Handle *)jarg1;
94245 }
94246
94247 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94248     return (Dali::Handle *)jarg1;
94249 }
94250
94251 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94252     return (Dali::BaseHandle *)jarg1;
94253 }
94254
94255 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94256     return (Dali::BaseHandle *)jarg1;
94257 }
94258
94259 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94260     return (Dali::Handle *)jarg1;
94261 }
94262
94263 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94264     return (Dali::BaseHandle *)jarg1;
94265 }
94266
94267 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94268     return (Dali::Handle *)jarg1;
94269 }
94270
94271 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94272     return (Dali::GestureDetector *)jarg1;
94273 }
94274
94275 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94276     return (Dali::Gesture *)jarg1;
94277 }
94278
94279 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94280     return (Dali::Handle *)jarg1;
94281 }
94282
94283 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94284     return (Dali::Actor *)jarg1;
94285 }
94286
94287 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94288     return (Dali::BaseHandle *)jarg1;
94289 }
94290
94291 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94292     return (Dali::RefObject *)jarg1;
94293 }
94294
94295 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94296     return (Dali::Actor *)jarg1;
94297 }
94298
94299 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94300     return (Dali::GestureDetector *)jarg1;
94301 }
94302
94303 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94304     return (Dali::Gesture *)jarg1;
94305 }
94306
94307 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94308     return (Dali::GestureDetector *)jarg1;
94309 }
94310
94311 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94312     return (Dali::Gesture *)jarg1;
94313 }
94314
94315 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94316     return (Dali::GestureDetector *)jarg1;
94317 }
94318
94319 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94320     return (Dali::Gesture *)jarg1;
94321 }
94322
94323 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94324     return (Dali::BaseHandle *)jarg1;
94325 }
94326
94327 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94328     return (Dali::Handle *)jarg1;
94329 }
94330
94331 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94332     return (Dali::BaseHandle *)jarg1;
94333 }
94334
94335 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94336     return (Dali::Handle *)jarg1;
94337 }
94338
94339 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94340     return (Dali::Handle *)jarg1;
94341 }
94342
94343 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94344     return (Dali::Image *)jarg1;
94345 }
94346
94347 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94348     return (Dali::Image *)jarg1;
94349 }
94350
94351 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94352     return (Dali::Image *)jarg1;
94353 }
94354
94355 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94356     return (Dali::RefObject *)jarg1;
94357 }
94358
94359 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94360     return (Dali::Image *)jarg1;
94361 }
94362
94363 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94364     return (Dali::Image *)jarg1;
94365 }
94366
94367 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94368     return (Dali::ResourceImage *)jarg1;
94369 }
94370
94371 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94372     return (Dali::Actor *)jarg1;
94373 }
94374
94375 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94376     return (Dali::BaseHandle *)jarg1;
94377 }
94378
94379 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94380     return (Dali::BaseHandle *)jarg1;
94381 }
94382
94383 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94384     return (Dali::BaseHandle *)jarg1;
94385 }
94386
94387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94388     return (Dali::BaseHandle *)jarg1;
94389 }
94390
94391 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94392     return (Dali::BaseHandle *)jarg1;
94393 }
94394
94395 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94396     return (Dali::BaseHandle *)jarg1;
94397 }
94398
94399 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94400     return (Dali::CustomActorImpl *)jarg1;
94401 }
94402
94403 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94404     return (Dali::CustomActor *)jarg1;
94405 }
94406
94407 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94408     return (Dali::BaseHandle *)jarg1;
94409 }
94410
94411 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94412     return (Dali::Toolkit::Control *)jarg1;
94413 }
94414
94415 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94416     return (Dali::Toolkit::Control *)jarg1;
94417 }
94418
94419 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94420     return (Dali::Toolkit::Button *)jarg1;
94421 }
94422
94423 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94424     return (Dali::Toolkit::Button *)jarg1;
94425 }
94426
94427 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94428     return (Dali::Toolkit::Button *)jarg1;
94429 }
94430
94431 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94432     return (Dali::Toolkit::Control *)jarg1;
94433 }
94434
94435 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94436     return (Dali::Toolkit::Control *)jarg1;
94437 }
94438
94439 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94440     return (Dali::Toolkit::Control *)jarg1;
94441 }
94442
94443 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94444     return (Dali::Toolkit::Control *)jarg1;
94445 }
94446
94447 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94448     return (Dali::Toolkit::Control *)jarg1;
94449 }
94450
94451 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94452     return (Dali::RefObject *)jarg1;
94453 }
94454
94455 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94456     return (Dali::Toolkit::Scrollable *)jarg1;
94457 }
94458
94459 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94460     return (Dali::BaseHandle *)jarg1;
94461 }
94462
94463 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94464     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94465 }
94466
94467 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94468     return (Dali::RefObject *)jarg1;
94469 }
94470
94471 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94472     return (Dali::Toolkit::Ruler *)jarg1;
94473 }
94474
94475 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94476     return (Dali::Toolkit::Ruler *)jarg1;
94477 }
94478
94479 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94480     return (Dali::Toolkit::Scrollable *)jarg1;
94481 }
94482
94483 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94484     return (Dali::Toolkit::Control *)jarg1;
94485 }
94486
94487 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94488     return (Dali::Toolkit::Control *)jarg1;
94489 }
94490
94491 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94492     return (Dali::Toolkit::Control *)jarg1;
94493 }
94494
94495 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94496     return (Dali::Toolkit::Control *)jarg1;
94497 }
94498
94499 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94500     return (Dali::BaseHandle *)jarg1;
94501 }
94502
94503 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94504     return (Dali::BaseHandle *)jarg1;
94505 }
94506
94507 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94508     return (Dali::Toolkit::Control *)jarg1;
94509 }
94510
94511 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94512     return (Dali::Toolkit::Control *)jarg1;
94513 }
94514
94515 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94516     return (Dali::Toolkit::Control *)jarg1;
94517 }
94518
94519 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94520     return (Dali::Toolkit::Control *)jarg1;
94521 }
94522
94523 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94524     return (Dali::Toolkit::Control *)jarg1;
94525 }
94526
94527 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94528     return (Dali::Toolkit::Control *)jarg1;
94529 }
94530
94531 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94532     return (Dali::Toolkit::PageTurnView *)jarg1;
94533 }
94534
94535 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94536     return (Dali::Toolkit::PageTurnView *)jarg1;
94537 }
94538
94539 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94540     return (Dali::Toolkit::Button *)jarg1;
94541 }
94542
94543 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94544     return (Dali::BaseHandle *)jarg1;
94545 }
94546
94547 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94548     return (Dali::BaseHandle *)jarg1;
94549 }
94550
94551 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94552     return (Dali::BaseHandle *)jarg1;
94553 }
94554
94555
94556
94557
94558
94559 //////////////////////////////////////////////////
94560 //from dali-swig autogeneration (from dali_wrap.cpp)
94561
94562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94563   void * jresult ;
94564   Dali::ImfManager::ImfEventData *result = 0 ;
94565
94566   {
94567     try {
94568       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94569     } catch (std::out_of_range& e) {
94570       {
94571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94572       };
94573     } catch (std::exception& e) {
94574       {
94575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94576       };
94577     } catch (...) {
94578       {
94579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94580       };
94581     }
94582   }
94583   jresult = (void *)result;
94584   return jresult;
94585 }
94586
94587
94588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94589   void * jresult ;
94590   Dali::ImfManager::ImfEvent arg1 ;
94591   std::string *arg2 = 0 ;
94592   int arg3 ;
94593   int arg4 ;
94594   Dali::ImfManager::ImfEventData *result = 0 ;
94595
94596   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94597   if (!jarg2) {
94598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94599     return 0;
94600   }
94601   std::string arg2_str(jarg2);
94602   arg2 = &arg2_str;
94603   arg3 = (int)jarg3;
94604   arg4 = (int)jarg4;
94605   {
94606     try {
94607       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94608     } catch (std::out_of_range& e) {
94609       {
94610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94611       };
94612     } catch (std::exception& e) {
94613       {
94614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94615       };
94616     } catch (...) {
94617       {
94618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94619       };
94620     }
94621   }
94622   jresult = (void *)result;
94623
94624   //argout typemap for const std::string&
94625
94626   return jresult;
94627 }
94628
94629
94630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94631   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94632   std::string *arg2 = 0 ;
94633
94634   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94635   if (!jarg2) {
94636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94637     return ;
94638   }
94639   std::string arg2_str(jarg2);
94640   arg2 = &arg2_str;
94641   if (arg1) (arg1)->predictiveString = *arg2;
94642
94643   //argout typemap for const std::string&
94644
94645 }
94646
94647
94648 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94649   char * jresult ;
94650   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94651   std::string *result = 0 ;
94652
94653   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94654   result = (std::string *) & ((arg1)->predictiveString);
94655   jresult = SWIG_csharp_string_callback(result->c_str());
94656   return jresult;
94657 }
94658
94659
94660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94661   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94662   Dali::ImfManager::ImfEvent arg2 ;
94663
94664   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94665   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94666   if (arg1) (arg1)->eventName = arg2;
94667 }
94668
94669
94670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94671   int jresult ;
94672   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94673   Dali::ImfManager::ImfEvent result;
94674
94675   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94676   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94677   jresult = (int)result;
94678   return jresult;
94679 }
94680
94681
94682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94683   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94684   int arg2 ;
94685
94686   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94687   arg2 = (int)jarg2;
94688   if (arg1) (arg1)->cursorOffset = arg2;
94689 }
94690
94691
94692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94693   int jresult ;
94694   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94695   int result;
94696
94697   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94698   result = (int) ((arg1)->cursorOffset);
94699   jresult = result;
94700   return jresult;
94701 }
94702
94703
94704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94705   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94706   int arg2 ;
94707
94708   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94709   arg2 = (int)jarg2;
94710   if (arg1) (arg1)->numberOfChars = arg2;
94711 }
94712
94713
94714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94715   int jresult ;
94716   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94717   int result;
94718
94719   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94720   result = (int) ((arg1)->numberOfChars);
94721   jresult = result;
94722   return jresult;
94723 }
94724
94725
94726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94727   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94728
94729   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94730   {
94731     try {
94732       delete arg1;
94733     } catch (std::out_of_range& e) {
94734       {
94735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94736       };
94737     } catch (std::exception& e) {
94738       {
94739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94740       };
94741     } catch (...) {
94742       {
94743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94744       };
94745     }
94746   }
94747 }
94748
94749
94750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94751   void * jresult ;
94752   Dali::ImfManager::ImfCallbackData *result = 0 ;
94753
94754   {
94755     try {
94756       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94757     } catch (std::out_of_range& e) {
94758       {
94759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94760       };
94761     } catch (std::exception& e) {
94762       {
94763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94764       };
94765     } catch (...) {
94766       {
94767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94768       };
94769     }
94770   }
94771   jresult = (void *)result;
94772   return jresult;
94773 }
94774
94775
94776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94777   void * jresult ;
94778   bool arg1 ;
94779   int arg2 ;
94780   std::string *arg3 = 0 ;
94781   bool arg4 ;
94782   Dali::ImfManager::ImfCallbackData *result = 0 ;
94783
94784   arg1 = jarg1 ? true : false;
94785   arg2 = (int)jarg2;
94786   if (!jarg3) {
94787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94788     return 0;
94789   }
94790   std::string arg3_str(jarg3);
94791   arg3 = &arg3_str;
94792   arg4 = jarg4 ? true : false;
94793   {
94794     try {
94795       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94796     } catch (std::out_of_range& e) {
94797       {
94798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94799       };
94800     } catch (std::exception& e) {
94801       {
94802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94803       };
94804     } catch (...) {
94805       {
94806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94807       };
94808     }
94809   }
94810   jresult = (void *)result;
94811
94812   //argout typemap for const std::string&
94813
94814   return jresult;
94815 }
94816
94817
94818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94819   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94820   std::string *arg2 = 0 ;
94821
94822   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94823   if (!jarg2) {
94824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94825     return ;
94826   }
94827   std::string arg2_str(jarg2);
94828   arg2 = &arg2_str;
94829   if (arg1) (arg1)->currentText = *arg2;
94830
94831   //argout typemap for const std::string&
94832
94833 }
94834
94835
94836 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94837   char * jresult ;
94838   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94839   std::string *result = 0 ;
94840
94841   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94842   result = (std::string *) & ((arg1)->currentText);
94843   jresult = SWIG_csharp_string_callback(result->c_str());
94844   return jresult;
94845 }
94846
94847
94848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94849   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94850   int arg2 ;
94851
94852   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94853   arg2 = (int)jarg2;
94854   if (arg1) (arg1)->cursorPosition = arg2;
94855 }
94856
94857
94858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94859   int jresult ;
94860   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94861   int result;
94862
94863   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94864   result = (int) ((arg1)->cursorPosition);
94865   jresult = result;
94866   return jresult;
94867 }
94868
94869
94870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94871   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94872   bool arg2 ;
94873
94874   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94875   arg2 = jarg2 ? true : false;
94876   if (arg1) (arg1)->update = arg2;
94877 }
94878
94879
94880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94881   unsigned int jresult ;
94882   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94883   bool result;
94884
94885   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94886   result = (bool) ((arg1)->update);
94887   jresult = result;
94888   return jresult;
94889 }
94890
94891
94892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94893   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94894   bool arg2 ;
94895
94896   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94897   arg2 = jarg2 ? true : false;
94898   if (arg1) (arg1)->preeditResetRequired = arg2;
94899 }
94900
94901
94902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94903   unsigned int jresult ;
94904   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94905   bool result;
94906
94907   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94908   result = (bool) ((arg1)->preeditResetRequired);
94909   jresult = result;
94910   return jresult;
94911 }
94912
94913
94914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94915   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94916
94917   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94918   {
94919     try {
94920       delete arg1;
94921     } catch (std::out_of_range& e) {
94922       {
94923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94924       };
94925     } catch (std::exception& e) {
94926       {
94927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94928       };
94929     } catch (...) {
94930       {
94931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94932       };
94933     }
94934   }
94935 }
94936
94937
94938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94939   void * jresult ;
94940   Dali::ImfManager result;
94941
94942   {
94943     try {
94944       result = Dali::ImfManager::Get();
94945     } catch (std::out_of_range& e) {
94946       {
94947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94948       };
94949     } catch (std::exception& e) {
94950       {
94951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94952       };
94953     } catch (...) {
94954       {
94955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94956       };
94957     }
94958   }
94959   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94960   return jresult;
94961 }
94962
94963
94964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94965   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94966
94967   arg1 = (Dali::ImfManager *)jarg1;
94968   {
94969     try {
94970       (arg1)->Activate();
94971     } catch (std::out_of_range& e) {
94972       {
94973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94974       };
94975     } catch (std::exception& e) {
94976       {
94977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94978       };
94979     } catch (...) {
94980       {
94981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94982       };
94983     }
94984   }
94985 }
94986
94987
94988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
94989   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94990
94991   arg1 = (Dali::ImfManager *)jarg1;
94992   {
94993     try {
94994       (arg1)->Deactivate();
94995     } catch (std::out_of_range& e) {
94996       {
94997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94998       };
94999     } catch (std::exception& e) {
95000       {
95001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95002       };
95003     } catch (...) {
95004       {
95005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95006       };
95007     }
95008   }
95009 }
95010
95011
95012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
95013   unsigned int jresult ;
95014   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95015   bool result;
95016
95017   arg1 = (Dali::ImfManager *)jarg1;
95018   {
95019     try {
95020       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
95021     } catch (std::out_of_range& e) {
95022       {
95023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95024       };
95025     } catch (std::exception& e) {
95026       {
95027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95028       };
95029     } catch (...) {
95030       {
95031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95032       };
95033     }
95034   }
95035   jresult = result;
95036   return jresult;
95037 }
95038
95039
95040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
95041   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95042   bool arg2 ;
95043
95044   arg1 = (Dali::ImfManager *)jarg1;
95045   arg2 = jarg2 ? true : false;
95046   {
95047     try {
95048       (arg1)->SetRestoreAfterFocusLost(arg2);
95049     } catch (std::out_of_range& e) {
95050       {
95051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95052       };
95053     } catch (std::exception& e) {
95054       {
95055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95056       };
95057     } catch (...) {
95058       {
95059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95060       };
95061     }
95062   }
95063 }
95064
95065
95066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
95067   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95068
95069   arg1 = (Dali::ImfManager *)jarg1;
95070   {
95071     try {
95072       (arg1)->Reset();
95073     } catch (std::out_of_range& e) {
95074       {
95075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95076       };
95077     } catch (std::exception& e) {
95078       {
95079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95080       };
95081     } catch (...) {
95082       {
95083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95084       };
95085     }
95086   }
95087 }
95088
95089
95090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
95091   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95092
95093   arg1 = (Dali::ImfManager *)jarg1;
95094   {
95095     try {
95096       (arg1)->NotifyCursorPosition();
95097     } catch (std::out_of_range& e) {
95098       {
95099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95100       };
95101     } catch (std::exception& e) {
95102       {
95103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95104       };
95105     } catch (...) {
95106       {
95107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95108       };
95109     }
95110   }
95111 }
95112
95113
95114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95115   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95116   unsigned int arg2 ;
95117
95118   arg1 = (Dali::ImfManager *)jarg1;
95119   arg2 = (unsigned int)jarg2;
95120   {
95121     try {
95122       (arg1)->SetCursorPosition(arg2);
95123     } catch (std::out_of_range& e) {
95124       {
95125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95126       };
95127     } catch (std::exception& e) {
95128       {
95129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95130       };
95131     } catch (...) {
95132       {
95133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95134       };
95135     }
95136   }
95137 }
95138
95139
95140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95141   unsigned int jresult ;
95142   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95143   unsigned int result;
95144
95145   arg1 = (Dali::ImfManager *)jarg1;
95146   {
95147     try {
95148       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95149     } catch (std::out_of_range& e) {
95150       {
95151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95152       };
95153     } catch (std::exception& e) {
95154       {
95155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95156       };
95157     } catch (...) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95160       };
95161     }
95162   }
95163   jresult = result;
95164   return jresult;
95165 }
95166
95167
95168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95169   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95170   std::string *arg2 = 0 ;
95171
95172   arg1 = (Dali::ImfManager *)jarg1;
95173   if (!jarg2) {
95174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95175     return ;
95176   }
95177   std::string arg2_str(jarg2);
95178   arg2 = &arg2_str;
95179   {
95180     try {
95181       (arg1)->SetSurroundingText((std::string const &)*arg2);
95182     } catch (std::out_of_range& e) {
95183       {
95184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95185       };
95186     } catch (std::exception& e) {
95187       {
95188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95189       };
95190     } catch (...) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95193       };
95194     }
95195   }
95196
95197   //argout typemap for const std::string&
95198
95199 }
95200
95201
95202 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95203   char * jresult ;
95204   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95205   std::string *result = 0 ;
95206
95207   arg1 = (Dali::ImfManager *)jarg1;
95208   {
95209     try {
95210       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95211     } catch (std::out_of_range& e) {
95212       {
95213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95214       };
95215     } catch (std::exception& e) {
95216       {
95217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95218       };
95219     } catch (...) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95222       };
95223     }
95224   }
95225   jresult = SWIG_csharp_string_callback(result->c_str());
95226   return jresult;
95227 }
95228
95229
95230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95231   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95232   bool arg2 ;
95233
95234   arg1 = (Dali::ImfManager *)jarg1;
95235   arg2 = jarg2 ? true : false;
95236   {
95237     try {
95238       (arg1)->NotifyTextInputMultiLine(arg2);
95239     } catch (std::out_of_range& e) {
95240       {
95241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95242       };
95243     } catch (std::exception& e) {
95244       {
95245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95246       };
95247     } catch (...) {
95248       {
95249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95250       };
95251     }
95252   }
95253 }
95254
95255
95256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95257   int jresult ;
95258   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95259   Dali::ImfManager::TextDirection result;
95260
95261   arg1 = (Dali::ImfManager *)jarg1;
95262   {
95263     try {
95264       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95265     } catch (std::out_of_range& e) {
95266       {
95267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95268       };
95269     } catch (std::exception& e) {
95270       {
95271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95272       };
95273     } catch (...) {
95274       {
95275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95276       };
95277     }
95278   }
95279   jresult = (int)result;
95280   return jresult;
95281 }
95282
95283
95284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95285   void * jresult ;
95286   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95287   Dali::Rect< int > result;
95288
95289   arg1 = (Dali::ImfManager *)jarg1;
95290   {
95291     try {
95292       result = (arg1)->GetInputMethodArea();
95293     } catch (std::out_of_range& e) {
95294       {
95295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95296       };
95297     } catch (std::exception& e) {
95298       {
95299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95300       };
95301     } catch (...) {
95302       {
95303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95304       };
95305     }
95306   }
95307   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95308   return jresult;
95309 }
95310
95311
95312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95313   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95314   Dali::InputMethodOptions *arg2 = 0 ;
95315
95316   arg1 = (Dali::ImfManager *)jarg1;
95317   arg2 = (Dali::InputMethodOptions *)jarg2;
95318   if (!arg2) {
95319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95320     return ;
95321   }
95322   {
95323     try {
95324       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95325     } catch (std::out_of_range& e) {
95326       {
95327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95328       };
95329     } catch (std::exception& e) {
95330       {
95331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95332       };
95333     } catch (...) {
95334       {
95335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95336       };
95337     }
95338   }
95339 }
95340
95341
95342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95343   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95344   std::string *arg2 = 0 ;
95345
95346   arg1 = (Dali::ImfManager *)jarg1;
95347   if (!jarg2) {
95348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95349     return ;
95350   }
95351   std::string arg2_str(jarg2);
95352   arg2 = &arg2_str;
95353   {
95354     try {
95355       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95356     } catch (std::out_of_range& e) {
95357       {
95358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95359       };
95360     } catch (std::exception& e) {
95361       {
95362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95363       };
95364     } catch (...) {
95365       {
95366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95367       };
95368     }
95369   }
95370
95371   //argout typemap for const std::string&
95372
95373 }
95374
95375
95376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95377   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95378   std::string *arg2 = 0 ;
95379
95380   arg1 = (Dali::ImfManager *)jarg1;
95381   if (!jarg2) {
95382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95383     return ;
95384   }
95385   std::string arg2_str(jarg2);
95386   arg2 = &arg2_str;
95387   {
95388     try {
95389       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95390     } catch (std::out_of_range& e) {
95391       {
95392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95393       };
95394     } catch (std::exception& e) {
95395       {
95396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95397       };
95398     } catch (...) {
95399       {
95400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95401       };
95402     }
95403   }
95404
95405 }
95406
95407
95408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95409   int jresult ;
95410   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95411   Dali::ImfManager::State result;
95412
95413   arg1 = (Dali::ImfManager *)jarg1;
95414   {
95415     try {
95416       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95417     } catch (std::out_of_range& e) {
95418       {
95419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95420       };
95421     } catch (std::exception& e) {
95422       {
95423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95424       };
95425     } catch (...) {
95426       {
95427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95428       };
95429     }
95430   }
95431   jresult = (int)result;
95432   return jresult;
95433 }
95434
95435
95436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95437   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95438   bool arg2 ;
95439
95440   arg1 = (Dali::ImfManager *)jarg1;
95441   arg2 = jarg2 ? true : false;
95442   {
95443     try {
95444       (arg1)->SetReturnKeyState(arg2);
95445     } catch (std::out_of_range& e) {
95446       {
95447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95448       };
95449     } catch (std::exception& e) {
95450       {
95451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95452       };
95453     } catch (...) {
95454       {
95455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95456       };
95457     }
95458   }
95459 }
95460
95461
95462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95463   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95464   bool arg2 ;
95465
95466   arg1 = (Dali::ImfManager *)jarg1;
95467   arg2 = jarg2 ? true : false;
95468   {
95469     try {
95470       (arg1)->AutoEnableInputPanel(arg2);
95471     } catch (std::out_of_range& e) {
95472       {
95473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (std::exception& e) {
95476       {
95477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95482       };
95483     }
95484   }
95485 }
95486
95487
95488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95489   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95490
95491   arg1 = (Dali::ImfManager *)jarg1;
95492   {
95493     try {
95494       (arg1)->ShowInputPanel();
95495     } catch (std::out_of_range& e) {
95496       {
95497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95498       };
95499     } catch (std::exception& e) {
95500       {
95501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95502       };
95503     } catch (...) {
95504       {
95505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95506       };
95507     }
95508   }
95509 }
95510
95511
95512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95513   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95514
95515   arg1 = (Dali::ImfManager *)jarg1;
95516   {
95517     try {
95518       (arg1)->HideInputPanel();
95519     } catch (std::out_of_range& e) {
95520       {
95521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95522       };
95523     } catch (std::exception& e) {
95524       {
95525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95526       };
95527     } catch (...) {
95528       {
95529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95530       };
95531     }
95532   }
95533 }
95534
95535
95536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95537   void * jresult ;
95538   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95539   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95540
95541   arg1 = (Dali::ImfManager *)jarg1;
95542   {
95543     try {
95544       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95545     } catch (std::out_of_range& e) {
95546       {
95547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95548       };
95549     } catch (std::exception& e) {
95550       {
95551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95552       };
95553     } catch (...) {
95554       {
95555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95556       };
95557     }
95558   }
95559   jresult = (void *)result;
95560   return jresult;
95561 }
95562
95563
95564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95565   void * jresult ;
95566   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95567   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95568
95569   arg1 = (Dali::ImfManager *)jarg1;
95570   {
95571     try {
95572       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95573     } catch (std::out_of_range& e) {
95574       {
95575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95576       };
95577     } catch (std::exception& e) {
95578       {
95579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95580       };
95581     } catch (...) {
95582       {
95583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95584       };
95585     }
95586   }
95587   jresult = (void *)result;
95588   return jresult;
95589 }
95590
95591
95592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95593   void * jresult ;
95594   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95595   Dali::ImfManager::StatusSignalType *result = 0 ;
95596
95597   arg1 = (Dali::ImfManager *)jarg1;
95598   {
95599     try {
95600       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95601     } catch (std::out_of_range& e) {
95602       {
95603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95604       };
95605     } catch (std::exception& e) {
95606       {
95607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95608       };
95609     } catch (...) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95612       };
95613     }
95614   }
95615   jresult = (void *)result;
95616   return jresult;
95617 }
95618
95619
95620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95621   void * jresult ;
95622   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95623   Dali::ImfManager::VoidSignalType *result = 0 ;
95624
95625   arg1 = (Dali::ImfManager *)jarg1;
95626   {
95627     try {
95628       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95629     } catch (std::out_of_range& e) {
95630       {
95631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95632       };
95633     } catch (std::exception& e) {
95634       {
95635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95636       };
95637     } catch (...) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95640       };
95641     }
95642   }
95643   jresult = (void *)result;
95644   return jresult;
95645 }
95646
95647
95648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95649   void * jresult ;
95650   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95651   Dali::ImfManager::VoidSignalType *result = 0 ;
95652
95653   arg1 = (Dali::ImfManager *)jarg1;
95654   {
95655     try {
95656       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95657     } catch (std::out_of_range& e) {
95658       {
95659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95660       };
95661     } catch (std::exception& e) {
95662       {
95663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95664       };
95665     } catch (...) {
95666       {
95667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95668       };
95669     }
95670   }
95671   jresult = (void *)result;
95672   return jresult;
95673 }
95674
95675
95676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95677   void * jresult ;
95678   Dali::ImfManager *result = 0 ;
95679
95680   {
95681     try {
95682       result = (Dali::ImfManager *)new Dali::ImfManager();
95683     } catch (std::out_of_range& e) {
95684       {
95685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (std::exception& e) {
95688       {
95689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95690       };
95691     } catch (...) {
95692       {
95693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95694       };
95695     }
95696   }
95697   jresult = (void *)result;
95698   return jresult;
95699 }
95700
95701
95702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95703   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95704
95705   arg1 = (Dali::ImfManager *)jarg1;
95706   {
95707     try {
95708       delete arg1;
95709     } catch (std::out_of_range& e) {
95710       {
95711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95712       };
95713     } catch (std::exception& e) {
95714       {
95715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95716       };
95717     } catch (...) {
95718       {
95719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95720       };
95721     }
95722   }
95723 }
95724
95725
95726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95727   void * jresult ;
95728   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95729   Dali::ImfManager *result = 0 ;
95730
95731   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95732   {
95733     try {
95734       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95735     } catch (std::out_of_range& e) {
95736       {
95737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95738       };
95739     } catch (std::exception& e) {
95740       {
95741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95742       };
95743     } catch (...) {
95744       {
95745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95746       };
95747     }
95748   }
95749   jresult = (void *)result;
95750   return jresult;
95751 }
95752
95753
95754 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95755     return (Dali::BaseHandle *)jarg1;
95756 }
95757
95758
95759 //////////////////////////////////////////////////
95760 //from dali-swig autogeneration (from dali_wrap.cpp)
95761
95762
95763
95764
95765
95766
95767
95768
95769
95770
95771
95772
95773 #ifdef __cplusplus
95774 }
95775 #endif
95776