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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
53548   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53549
53550   arg1 = (Dali::ApplicationExtensions *)jarg1;
53551   {
53552     try {
53553       (arg1)->Start();
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53561       };
53562     } catch (...) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53565       };
53566     }
53567   }
53568 }
53569
53570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53571   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53572
53573   arg1 = (Dali::ApplicationExtensions *)jarg1;
53574   {
53575     try {
53576       (arg1)->Terminate();
53577     } catch (std::out_of_range& e) {
53578       {
53579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53580       };
53581     } catch (std::exception& e) {
53582       {
53583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (...) {
53586       {
53587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53588       };
53589     }
53590   }
53591 }
53592
53593
53594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53595   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53596
53597   arg1 = (Dali::ApplicationExtensions *)jarg1;
53598   {
53599     try {
53600       (arg1)->Pause();
53601     } catch (std::out_of_range& e) {
53602       {
53603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53604       };
53605     } catch (std::exception& e) {
53606       {
53607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (...) {
53610       {
53611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53612       };
53613     }
53614   }
53615 }
53616
53617
53618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53619   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53620
53621   arg1 = (Dali::ApplicationExtensions *)jarg1;
53622   {
53623     try {
53624       (arg1)->Resume();
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53636       };
53637     }
53638   }
53639 }
53640
53641
53642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53643   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53644
53645   arg1 = (Dali::ApplicationExtensions *)jarg1;
53646   {
53647     try {
53648       (arg1)->LanguageChange();
53649     } catch (std::out_of_range& e) {
53650       {
53651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (std::exception& e) {
53654       {
53655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663 }
53664
53665
53666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53667   void * jresult ;
53668   Dali::PositionSize arg1 ;
53669   std::string *arg2 = 0 ;
53670   bool arg3 ;
53671   Dali::PositionSize *argp1 ;
53672   Dali::Window result;
53673
53674   argp1 = (Dali::PositionSize *)jarg1;
53675   if (!argp1) {
53676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53677     return 0;
53678   }
53679   arg1 = *argp1;
53680   if (!jarg2) {
53681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53682     return 0;
53683   }
53684   std::string arg2_str(jarg2);
53685   arg2 = &arg2_str;
53686   arg3 = jarg3 ? true : false;
53687   {
53688     try {
53689       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53690     } catch (std::out_of_range& e) {
53691       {
53692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53693       };
53694     } catch (std::exception& e) {
53695       {
53696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53697       };
53698     } catch (...) {
53699       {
53700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53701       };
53702     }
53703   }
53704   jresult = new Dali::Window((const Dali::Window &)result);
53705
53706   //argout typemap for const std::string&
53707
53708   return jresult;
53709 }
53710
53711
53712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53713   void * jresult ;
53714   Dali::PositionSize arg1 ;
53715   std::string *arg2 = 0 ;
53716   Dali::PositionSize *argp1 ;
53717   Dali::Window result;
53718
53719   argp1 = (Dali::PositionSize *)jarg1;
53720   if (!argp1) {
53721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53722     return 0;
53723   }
53724   arg1 = *argp1;
53725   if (!jarg2) {
53726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53727     return 0;
53728   }
53729   std::string arg2_str(jarg2);
53730   arg2 = &arg2_str;
53731   {
53732     try {
53733       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53734     } catch (std::out_of_range& e) {
53735       {
53736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53737       };
53738     } catch (std::exception& e) {
53739       {
53740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53741       };
53742     } catch (...) {
53743       {
53744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53745       };
53746     }
53747   }
53748   jresult = new Dali::Window((const Dali::Window &)result);
53749
53750   //argout typemap for const std::string&
53751
53752   return jresult;
53753 }
53754
53755
53756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53757   void * jresult ;
53758   Dali::PositionSize arg1 ;
53759   std::string *arg2 = 0 ;
53760   std::string *arg3 = 0 ;
53761   bool arg4 ;
53762   Dali::PositionSize *argp1 ;
53763   Dali::Window result;
53764
53765   argp1 = (Dali::PositionSize *)jarg1;
53766   if (!argp1) {
53767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53768     return 0;
53769   }
53770   arg1 = *argp1;
53771   if (!jarg2) {
53772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53773     return 0;
53774   }
53775   std::string arg2_str(jarg2);
53776   arg2 = &arg2_str;
53777   if (!jarg3) {
53778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53779     return 0;
53780   }
53781   std::string arg3_str(jarg3);
53782   arg3 = &arg3_str;
53783   arg4 = jarg4 ? true : false;
53784   {
53785     try {
53786       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53787     } catch (std::out_of_range& e) {
53788       {
53789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53790       };
53791     } catch (std::exception& e) {
53792       {
53793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53794       };
53795     } catch (...) {
53796       {
53797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53798       };
53799     }
53800   }
53801   jresult = new Dali::Window((const Dali::Window &)result);
53802
53803   //argout typemap for const std::string&
53804
53805
53806   //argout typemap for const std::string&
53807
53808   return jresult;
53809 }
53810
53811
53812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53813   void * jresult ;
53814   Dali::PositionSize arg1 ;
53815   std::string *arg2 = 0 ;
53816   std::string *arg3 = 0 ;
53817   Dali::PositionSize *argp1 ;
53818   Dali::Window result;
53819
53820   argp1 = (Dali::PositionSize *)jarg1;
53821   if (!argp1) {
53822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53823     return 0;
53824   }
53825   arg1 = *argp1;
53826   if (!jarg2) {
53827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53828     return 0;
53829   }
53830   std::string arg2_str(jarg2);
53831   arg2 = &arg2_str;
53832   if (!jarg3) {
53833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53834     return 0;
53835   }
53836   std::string arg3_str(jarg3);
53837   arg3 = &arg3_str;
53838   {
53839     try {
53840       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53841     } catch (std::out_of_range& e) {
53842       {
53843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53844       };
53845     } catch (std::exception& e) {
53846       {
53847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53848       };
53849     } catch (...) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53852       };
53853     }
53854   }
53855   jresult = new Dali::Window((const Dali::Window &)result);
53856
53857   //argout typemap for const std::string&
53858
53859
53860   //argout typemap for const std::string&
53861
53862   return jresult;
53863 }
53864
53865
53866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53867   void * jresult ;
53868   Dali::Window *result = 0 ;
53869
53870   {
53871     try {
53872       result = (Dali::Window *)new Dali::Window();
53873     } catch (std::out_of_range& e) {
53874       {
53875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (std::exception& e) {
53878       {
53879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (...) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53884       };
53885     }
53886   }
53887   jresult = (void *)result;
53888   return jresult;
53889 }
53890
53891
53892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53893   Dali::Window *arg1 = (Dali::Window *) 0 ;
53894
53895   arg1 = (Dali::Window *)jarg1;
53896   {
53897     try {
53898       delete arg1;
53899     } catch (std::out_of_range& e) {
53900       {
53901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53902       };
53903     } catch (std::exception& e) {
53904       {
53905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53910       };
53911     }
53912   }
53913 }
53914
53915
53916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53917   void * jresult ;
53918   Dali::Window *arg1 = 0 ;
53919   Dali::Window *result = 0 ;
53920
53921   arg1 = (Dali::Window *)jarg1;
53922   if (!arg1) {
53923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53924     return 0;
53925   }
53926   {
53927     try {
53928       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53929     } catch (std::out_of_range& e) {
53930       {
53931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53932       };
53933     } catch (std::exception& e) {
53934       {
53935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (...) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53940       };
53941     }
53942   }
53943   jresult = (void *)result;
53944   return jresult;
53945 }
53946
53947
53948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53949   void * jresult ;
53950   Dali::Window *arg1 = (Dali::Window *) 0 ;
53951   Dali::Window *arg2 = 0 ;
53952   Dali::Window *result = 0 ;
53953
53954   arg1 = (Dali::Window *)jarg1;
53955   arg2 = (Dali::Window *)jarg2;
53956   if (!arg2) {
53957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53958     return 0;
53959   }
53960   {
53961     try {
53962       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53970       };
53971     } catch (...) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53974       };
53975     }
53976   }
53977   jresult = (void *)result;
53978   return jresult;
53979 }
53980
53981
53982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53983   Dali::Window *arg1 = (Dali::Window *) 0 ;
53984   Dali::Window::IndicatorVisibleMode arg2 ;
53985
53986   arg1 = (Dali::Window *)jarg1;
53987   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53988   {
53989     try {
53990       (arg1)->ShowIndicator(arg2);
53991     } catch (std::out_of_range& e) {
53992       {
53993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53994       };
53995     } catch (std::exception& e) {
53996       {
53997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (...) {
54000       {
54001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54002       };
54003     }
54004   }
54005 }
54006
54007
54008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
54009   Dali::Window *arg1 = (Dali::Window *) 0 ;
54010   Dali::Window::IndicatorBgOpacity arg2 ;
54011
54012   arg1 = (Dali::Window *)jarg1;
54013   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
54014   {
54015     try {
54016       (arg1)->SetIndicatorBgOpacity(arg2);
54017     } catch (std::out_of_range& e) {
54018       {
54019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54020       };
54021     } catch (std::exception& e) {
54022       {
54023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (...) {
54026       {
54027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54028       };
54029     }
54030   }
54031 }
54032
54033
54034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
54035   Dali::Window *arg1 = (Dali::Window *) 0 ;
54036   Dali::Window::WindowOrientation arg2 ;
54037
54038   arg1 = (Dali::Window *)jarg1;
54039   arg2 = (Dali::Window::WindowOrientation)jarg2;
54040   {
54041     try {
54042       (arg1)->RotateIndicator(arg2);
54043     } catch (std::out_of_range& e) {
54044       {
54045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54046       };
54047     } catch (std::exception& e) {
54048       {
54049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54050       };
54051     } catch (...) {
54052       {
54053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54054       };
54055     }
54056   }
54057 }
54058
54059
54060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
54061   Dali::Window *arg1 = (Dali::Window *) 0 ;
54062   std::string arg2 ;
54063   std::string arg3 ;
54064
54065   arg1 = (Dali::Window *)jarg1;
54066   if (!jarg2) {
54067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54068     return ;
54069   }
54070   (&arg2)->assign(jarg2);
54071   if (!jarg3) {
54072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54073     return ;
54074   }
54075   (&arg3)->assign(jarg3);
54076   {
54077     try {
54078       (arg1)->SetClass(arg2,arg3);
54079     } catch (std::out_of_range& e) {
54080       {
54081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54082       };
54083     } catch (std::exception& e) {
54084       {
54085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (...) {
54088       {
54089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54090       };
54091     }
54092   }
54093 }
54094
54095
54096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
54097   Dali::Window *arg1 = (Dali::Window *) 0 ;
54098
54099   arg1 = (Dali::Window *)jarg1;
54100   {
54101     try {
54102       (arg1)->Raise();
54103     } catch (std::out_of_range& e) {
54104       {
54105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54106       };
54107     } catch (std::exception& e) {
54108       {
54109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54110       };
54111     } catch (...) {
54112       {
54113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54114       };
54115     }
54116   }
54117 }
54118
54119
54120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54121   Dali::Window *arg1 = (Dali::Window *) 0 ;
54122
54123   arg1 = (Dali::Window *)jarg1;
54124   {
54125     try {
54126       (arg1)->Lower();
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (...) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54138       };
54139     }
54140   }
54141 }
54142
54143
54144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54145   Dali::Window *arg1 = (Dali::Window *) 0 ;
54146
54147   arg1 = (Dali::Window *)jarg1;
54148   {
54149     try {
54150       (arg1)->Activate();
54151     } catch (std::out_of_range& e) {
54152       {
54153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54154       };
54155     } catch (std::exception& e) {
54156       {
54157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (...) {
54160       {
54161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54162       };
54163     }
54164   }
54165 }
54166
54167
54168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54169   Dali::Window *arg1 = (Dali::Window *) 0 ;
54170   Dali::Window::WindowOrientation arg2 ;
54171
54172   arg1 = (Dali::Window *)jarg1;
54173   arg2 = (Dali::Window::WindowOrientation)jarg2;
54174   {
54175     try {
54176       (arg1)->AddAvailableOrientation(arg2);
54177     } catch (std::out_of_range& e) {
54178       {
54179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54180       };
54181     } catch (std::exception& e) {
54182       {
54183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54184       };
54185     } catch (...) {
54186       {
54187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54188       };
54189     }
54190   }
54191 }
54192
54193
54194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54195   Dali::Window *arg1 = (Dali::Window *) 0 ;
54196   Dali::Window::WindowOrientation arg2 ;
54197
54198   arg1 = (Dali::Window *)jarg1;
54199   arg2 = (Dali::Window::WindowOrientation)jarg2;
54200   {
54201     try {
54202       (arg1)->RemoveAvailableOrientation(arg2);
54203     } catch (std::out_of_range& e) {
54204       {
54205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54206       };
54207     } catch (std::exception& e) {
54208       {
54209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54210       };
54211     } catch (...) {
54212       {
54213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54214       };
54215     }
54216   }
54217 }
54218
54219
54220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54221   Dali::Window *arg1 = (Dali::Window *) 0 ;
54222   Dali::Window::WindowOrientation arg2 ;
54223
54224   arg1 = (Dali::Window *)jarg1;
54225   arg2 = (Dali::Window::WindowOrientation)jarg2;
54226   {
54227     try {
54228       (arg1)->SetPreferredOrientation(arg2);
54229     } catch (std::out_of_range& e) {
54230       {
54231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54232       };
54233     } catch (std::exception& e) {
54234       {
54235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54236       };
54237     } catch (...) {
54238       {
54239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54240       };
54241     }
54242   }
54243 }
54244
54245
54246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54247   int jresult ;
54248   Dali::Window *arg1 = (Dali::Window *) 0 ;
54249   Dali::Window::WindowOrientation result;
54250
54251   arg1 = (Dali::Window *)jarg1;
54252   {
54253     try {
54254       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54255     } catch (std::out_of_range& e) {
54256       {
54257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (std::exception& e) {
54260       {
54261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (...) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54266       };
54267     }
54268   }
54269   jresult = (int)result;
54270   return jresult;
54271 }
54272
54273
54274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54275   void * jresult ;
54276   Dali::Window *arg1 = (Dali::Window *) 0 ;
54277   Dali::DragAndDropDetector result;
54278
54279   arg1 = (Dali::Window *)jarg1;
54280   {
54281     try {
54282       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54283     } catch (std::out_of_range& e) {
54284       {
54285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54286       };
54287     } catch (std::exception& e) {
54288       {
54289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54290       };
54291     } catch (...) {
54292       {
54293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54294       };
54295     }
54296   }
54297   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54298   return jresult;
54299 }
54300
54301
54302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54303   void * jresult ;
54304   Dali::Window *arg1 = (Dali::Window *) 0 ;
54305   Dali::Any result;
54306
54307   arg1 = (Dali::Window *)jarg1;
54308   {
54309     try {
54310       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54311     } catch (std::out_of_range& e) {
54312       {
54313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54314       };
54315     } catch (std::exception& e) {
54316       {
54317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54322       };
54323     }
54324   }
54325   jresult = new Dali::Any((const Dali::Any &)result);
54326   return jresult;
54327 }
54328
54329
54330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54331   void * jresult ;
54332   Dali::Window arg1 ;
54333   Dali::Window *argp1 ;
54334   Dali::DevelWindow::FocusSignalType *result = 0 ;
54335
54336   argp1 = (Dali::Window *)jarg1;
54337   if (!argp1) {
54338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54339     return 0;
54340   }
54341   arg1 = *argp1;
54342   {
54343     try {
54344       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54345     } catch (std::out_of_range& e) {
54346       {
54347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (std::exception& e) {
54350       {
54351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (...) {
54354       {
54355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54356       };
54357     }
54358   }
54359   jresult = (void *)result;
54360   return jresult;
54361 }
54362
54363
54364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54365   Dali::Window arg1 ;
54366   bool arg2 ;
54367   Dali::Window *argp1 ;
54368
54369   argp1 = (Dali::Window *)jarg1;
54370   if (!argp1) {
54371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54372     return ;
54373   }
54374   arg1 = *argp1;
54375   arg2 = jarg2 ? true : false;
54376   {
54377     try {
54378       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (...) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54390       };
54391     }
54392   }
54393 }
54394
54395
54396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54397   unsigned int jresult ;
54398   Dali::Window arg1 ;
54399   Dali::Window *argp1 ;
54400   bool result;
54401
54402   argp1 = (Dali::Window *)jarg1;
54403   if (!argp1) {
54404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54405     return 0;
54406   }
54407   arg1 = *argp1;
54408   {
54409     try {
54410       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54411     } catch (std::out_of_range& e) {
54412       {
54413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54414       };
54415     } catch (std::exception& e) {
54416       {
54417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54418       };
54419     } catch (...) {
54420       {
54421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54422       };
54423     }
54424   }
54425   jresult = result;
54426   return jresult;
54427 }
54428
54429
54430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54431   Dali::Window arg1 ;
54432   Dali::Window *argp1 ;
54433
54434   argp1 = (Dali::Window *)jarg1;
54435   if (!argp1) {
54436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54437     return ;
54438   }
54439   arg1 = *argp1;
54440   {
54441     try {
54442       Dali::DevelWindow::Show(arg1);
54443     } catch (std::out_of_range& e) {
54444       {
54445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54446       };
54447     } catch (std::exception& e) {
54448       {
54449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54450       };
54451     } catch (...) {
54452       {
54453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54454       };
54455     }
54456   }
54457 }
54458
54459
54460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54461   Dali::Window arg1 ;
54462   Dali::Window *argp1 ;
54463
54464   argp1 = (Dali::Window *)jarg1;
54465   if (!argp1) {
54466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54467     return ;
54468   }
54469   arg1 = *argp1;
54470   {
54471     try {
54472       Dali::DevelWindow::Hide(arg1);
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54484       };
54485     }
54486   }
54487 }
54488
54489
54490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54491   unsigned int jresult ;
54492   Dali::Window arg1 ;
54493   Dali::Window *argp1 ;
54494   bool result;
54495
54496   argp1 = (Dali::Window *)jarg1;
54497   if (!argp1) {
54498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54499     return 0;
54500   }
54501   arg1 = *argp1;
54502   {
54503     try {
54504       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54505     } catch (std::out_of_range& e) {
54506       {
54507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54508       };
54509     } catch (std::exception& e) {
54510       {
54511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (...) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54516       };
54517     }
54518   }
54519   jresult = result;
54520   return jresult;
54521 }
54522
54523
54524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54525   unsigned int jresult ;
54526   Dali::Window arg1 ;
54527   Dali::Window *argp1 ;
54528   unsigned int result;
54529
54530   argp1 = (Dali::Window *)jarg1;
54531   if (!argp1) {
54532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54533     return 0;
54534   }
54535   arg1 = *argp1;
54536   {
54537     try {
54538       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54539     } catch (std::out_of_range& e) {
54540       {
54541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (std::exception& e) {
54544       {
54545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54550       };
54551     }
54552   }
54553   jresult = result;
54554   return jresult;
54555 }
54556
54557
54558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54559   char * jresult ;
54560   Dali::Window arg1 ;
54561   unsigned int arg2 ;
54562   Dali::Window *argp1 ;
54563   std::string result;
54564
54565   argp1 = (Dali::Window *)jarg1;
54566   if (!argp1) {
54567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54568     return 0;
54569   }
54570   arg1 = *argp1;
54571   arg2 = (unsigned int)jarg2;
54572   {
54573     try {
54574       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54575     } catch (std::out_of_range& e) {
54576       {
54577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54578       };
54579     } catch (std::exception& e) {
54580       {
54581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54582       };
54583     } catch (...) {
54584       {
54585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54586       };
54587     }
54588   }
54589   jresult = SWIG_csharp_string_callback((&result)->c_str());
54590   return jresult;
54591 }
54592
54593
54594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54595   unsigned int jresult ;
54596   Dali::Window arg1 ;
54597   std::string *arg2 = 0 ;
54598   std::string *arg3 = 0 ;
54599   Dali::Window *argp1 ;
54600   unsigned int result;
54601
54602   argp1 = (Dali::Window *)jarg1;
54603   if (!argp1) {
54604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54605     return 0;
54606   }
54607   arg1 = *argp1;
54608   if (!jarg2) {
54609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54610     return 0;
54611   }
54612   std::string arg2_str(jarg2);
54613   arg2 = &arg2_str;
54614   if (!jarg3) {
54615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54616     return 0;
54617   }
54618   std::string arg3_str(jarg3);
54619   arg3 = &arg3_str;
54620   {
54621     try {
54622       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54623     } catch (std::out_of_range& e) {
54624       {
54625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54626       };
54627     } catch (std::exception& e) {
54628       {
54629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54630       };
54631     } catch (...) {
54632       {
54633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54634       };
54635     }
54636   }
54637   jresult = result;
54638
54639   //argout typemap for const std::string&
54640
54641
54642   //argout typemap for const std::string&
54643
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54649   unsigned int jresult ;
54650   Dali::Window arg1 ;
54651   unsigned int arg2 ;
54652   Dali::Window *argp1 ;
54653   bool result;
54654
54655   argp1 = (Dali::Window *)jarg1;
54656   if (!argp1) {
54657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54658     return 0;
54659   }
54660   arg1 = *argp1;
54661   arg2 = (unsigned int)jarg2;
54662   {
54663     try {
54664       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54665     } catch (std::out_of_range& e) {
54666       {
54667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54668       };
54669     } catch (std::exception& e) {
54670       {
54671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54672       };
54673     } catch (...) {
54674       {
54675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54676       };
54677     }
54678   }
54679   jresult = result;
54680   return jresult;
54681 }
54682
54683
54684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54685   unsigned int jresult ;
54686   Dali::Window arg1 ;
54687   unsigned int arg2 ;
54688   std::string *arg3 = 0 ;
54689   Dali::Window *argp1 ;
54690   bool result;
54691
54692   argp1 = (Dali::Window *)jarg1;
54693   if (!argp1) {
54694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54695     return 0;
54696   }
54697   arg1 = *argp1;
54698   arg2 = (unsigned int)jarg2;
54699   if (!jarg3) {
54700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54701     return 0;
54702   }
54703   std::string arg3_str(jarg3);
54704   arg3 = &arg3_str;
54705   {
54706     try {
54707       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54708     } catch (std::out_of_range& e) {
54709       {
54710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54711       };
54712     } catch (std::exception& e) {
54713       {
54714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54715       };
54716     } catch (...) {
54717       {
54718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54719       };
54720     }
54721   }
54722   jresult = result;
54723
54724   //argout typemap for const std::string&
54725
54726   return jresult;
54727 }
54728
54729
54730 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54731   char * jresult ;
54732   Dali::Window arg1 ;
54733   unsigned int arg2 ;
54734   Dali::Window *argp1 ;
54735   std::string result;
54736
54737   argp1 = (Dali::Window *)jarg1;
54738   if (!argp1) {
54739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54740     return 0;
54741   }
54742   arg1 = *argp1;
54743   arg2 = (unsigned int)jarg2;
54744   {
54745     try {
54746       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54747     } catch (std::out_of_range& e) {
54748       {
54749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (std::exception& e) {
54752       {
54753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (...) {
54756       {
54757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54758       };
54759     }
54760   }
54761   jresult = SWIG_csharp_string_callback((&result)->c_str());
54762   return jresult;
54763 }
54764
54765
54766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54767   unsigned int jresult ;
54768   Dali::Window arg1 ;
54769   std::string *arg2 = 0 ;
54770   Dali::Window *argp1 ;
54771   unsigned int result;
54772
54773   argp1 = (Dali::Window *)jarg1;
54774   if (!argp1) {
54775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54776     return 0;
54777   }
54778   arg1 = *argp1;
54779   if (!jarg2) {
54780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54781     return 0;
54782   }
54783   std::string arg2_str(jarg2);
54784   arg2 = &arg2_str;
54785   {
54786     try {
54787       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (...) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54799       };
54800     }
54801   }
54802   jresult = result;
54803
54804   //argout typemap for const std::string&
54805
54806   return jresult;
54807 }
54808
54809
54810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54811   Dali::Window arg1 ;
54812   Dali::Rect< int > *arg2 = 0 ;
54813   Dali::Window *argp1 ;
54814
54815   argp1 = (Dali::Window *)jarg1;
54816   if (!argp1) {
54817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54818     return ;
54819   }
54820   arg1 = *argp1;
54821   arg2 = (Dali::Rect< int > *)jarg2;
54822   if (!arg2) {
54823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54824     return ;
54825   }
54826   {
54827     try {
54828       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54829     } catch (std::out_of_range& e) {
54830       {
54831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (std::exception& e) {
54834       {
54835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54840       };
54841     }
54842   }
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54847   Dali::Window arg1 ;
54848   Dali::DevelWindow::Type arg2 ;
54849   Dali::Window *argp1 ;
54850
54851   argp1 = (Dali::Window *)jarg1;
54852   if (!argp1) {
54853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54854     return ;
54855   }
54856   arg1 = *argp1;
54857   arg2 = (Dali::DevelWindow::Type)jarg2;
54858   {
54859     try {
54860       Dali::DevelWindow::SetType(arg1,arg2);
54861     } catch (std::out_of_range& e) {
54862       {
54863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54864       };
54865     } catch (std::exception& e) {
54866       {
54867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54868       };
54869     } catch (...) {
54870       {
54871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54872       };
54873     }
54874   }
54875 }
54876
54877
54878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54879   int jresult ;
54880   Dali::Window arg1 ;
54881   Dali::Window *argp1 ;
54882   Dali::DevelWindow::Type result;
54883
54884   argp1 = (Dali::Window *)jarg1;
54885   if (!argp1) {
54886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54887     return 0;
54888   }
54889   arg1 = *argp1;
54890   {
54891     try {
54892       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54893     } catch (std::out_of_range& e) {
54894       {
54895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54896       };
54897     } catch (std::exception& e) {
54898       {
54899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54904       };
54905     }
54906   }
54907   jresult = (int)result;
54908   return jresult;
54909 }
54910
54911
54912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54913   unsigned int jresult ;
54914   Dali::Window arg1 ;
54915   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54916   Dali::Window *argp1 ;
54917   bool result;
54918
54919   argp1 = (Dali::Window *)jarg1;
54920   if (!argp1) {
54921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54922     return 0;
54923   }
54924   arg1 = *argp1;
54925   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54926   {
54927     try {
54928       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54929     } catch (std::out_of_range& e) {
54930       {
54931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54932       };
54933     } catch (std::exception& e) {
54934       {
54935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54936       };
54937     } catch (...) {
54938       {
54939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54940       };
54941     }
54942   }
54943   jresult = result;
54944   return jresult;
54945 }
54946
54947
54948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54949   int jresult ;
54950   Dali::Window arg1 ;
54951   Dali::Window *argp1 ;
54952   Dali::DevelWindow::NotificationLevel::Type result;
54953
54954   argp1 = (Dali::Window *)jarg1;
54955   if (!argp1) {
54956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54957     return 0;
54958   }
54959   arg1 = *argp1;
54960   {
54961     try {
54962       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54963     } catch (std::out_of_range& e) {
54964       {
54965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54966       };
54967     } catch (std::exception& e) {
54968       {
54969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (...) {
54972       {
54973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54974       };
54975     }
54976   }
54977   jresult = (int)result;
54978   return jresult;
54979 }
54980
54981
54982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54983   Dali::Window arg1 ;
54984   bool arg2 ;
54985   Dali::Window *argp1 ;
54986
54987   argp1 = (Dali::Window *)jarg1;
54988   if (!argp1) {
54989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54990     return ;
54991   }
54992   arg1 = *argp1;
54993   arg2 = jarg2 ? true : false;
54994   {
54995     try {
54996       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54997     } catch (std::out_of_range& e) {
54998       {
54999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55000       };
55001     } catch (std::exception& e) {
55002       {
55003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55004       };
55005     } catch (...) {
55006       {
55007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55008       };
55009     }
55010   }
55011 }
55012
55013
55014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
55015   unsigned int jresult ;
55016   Dali::Window arg1 ;
55017   Dali::Window *argp1 ;
55018   bool result;
55019
55020   argp1 = (Dali::Window *)jarg1;
55021   if (!argp1) {
55022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55023     return 0;
55024   }
55025   arg1 = *argp1;
55026   {
55027     try {
55028       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
55029     } catch (std::out_of_range& e) {
55030       {
55031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55032       };
55033     } catch (std::exception& e) {
55034       {
55035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55040       };
55041     }
55042   }
55043   jresult = result;
55044   return jresult;
55045 }
55046
55047
55048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
55049   unsigned int jresult ;
55050   Dali::Window arg1 ;
55051   Dali::DevelWindow::ScreenMode::Type arg2 ;
55052   Dali::Window *argp1 ;
55053   bool result;
55054
55055   argp1 = (Dali::Window *)jarg1;
55056   if (!argp1) {
55057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55058     return 0;
55059   }
55060   arg1 = *argp1;
55061   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
55062   {
55063     try {
55064       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
55065     } catch (std::out_of_range& e) {
55066       {
55067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55068       };
55069     } catch (std::exception& e) {
55070       {
55071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55072       };
55073     } catch (...) {
55074       {
55075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55076       };
55077     }
55078   }
55079   jresult = result;
55080   return jresult;
55081 }
55082
55083
55084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
55085   int jresult ;
55086   Dali::Window arg1 ;
55087   Dali::Window *argp1 ;
55088   Dali::DevelWindow::ScreenMode::Type result;
55089
55090   argp1 = (Dali::Window *)jarg1;
55091   if (!argp1) {
55092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55093     return 0;
55094   }
55095   arg1 = *argp1;
55096   {
55097     try {
55098       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
55099     } catch (std::out_of_range& e) {
55100       {
55101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55102       };
55103     } catch (std::exception& e) {
55104       {
55105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55106       };
55107     } catch (...) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55110       };
55111     }
55112   }
55113   jresult = (int)result;
55114   return jresult;
55115 }
55116
55117
55118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55119   unsigned int jresult ;
55120   Dali::Window arg1 ;
55121   int arg2 ;
55122   Dali::Window *argp1 ;
55123   bool result;
55124
55125   argp1 = (Dali::Window *)jarg1;
55126   if (!argp1) {
55127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55128     return 0;
55129   }
55130   arg1 = *argp1;
55131   arg2 = (int)jarg2;
55132   {
55133     try {
55134       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55135     } catch (std::out_of_range& e) {
55136       {
55137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55138       };
55139     } catch (std::exception& e) {
55140       {
55141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55146       };
55147     }
55148   }
55149   jresult = result;
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55155   int jresult ;
55156   Dali::Window arg1 ;
55157   Dali::Window *argp1 ;
55158   int result;
55159
55160   argp1 = (Dali::Window *)jarg1;
55161   if (!argp1) {
55162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55163     return 0;
55164   }
55165   arg1 = *argp1;
55166   {
55167     try {
55168       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55169     } catch (std::out_of_range& e) {
55170       {
55171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (std::exception& e) {
55174       {
55175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183   jresult = result;
55184   return jresult;
55185 }
55186
55187
55188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55189   void * jresult ;
55190   Dali::Application result;
55191
55192   {
55193     try {
55194       result = Dali::Application::New();
55195     } catch (std::out_of_range& e) {
55196       {
55197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55198       };
55199     } catch (std::exception& e) {
55200       {
55201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55202       };
55203     } catch (...) {
55204       {
55205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55206       };
55207     }
55208   }
55209   jresult = new Dali::Application((const Dali::Application &)result);
55210   return jresult;
55211 }
55212
55213
55214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55215   void * jresult ;
55216   int *arg1 = (int *) 0 ;
55217   char ***arg2 ;
55218   Dali::Application result;
55219
55220   {
55221     // Todo generate argv data from the C# args
55222     char **array;         // two dimensional array
55223     int numStrings = 1;     // number of strings
55224     int stringLength = 30;      // max string length.
55225     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55226     argV = array;
55227
55228     // allocate the string data
55229     for( int i=0; i < numStrings; i++)
55230     {
55231       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55232     }
55233     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55234
55235     strcpy( array[0], "dali-csharp-app");
55236
55237     arg1 = &argC;
55238     arg2 = &argV;
55239   }
55240   {
55241     try {
55242       result = Dali::Application::New(arg1,arg2);
55243     } catch (std::out_of_range& e) {
55244       {
55245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55246       };
55247     } catch (std::exception& e) {
55248       {
55249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55250       };
55251     } catch (...) {
55252       {
55253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55254       };
55255     }
55256   }
55257   jresult = new Dali::Application((const Dali::Application &)result);
55258   return jresult;
55259 }
55260
55261
55262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55263   void * jresult ;
55264   int *arg1 = (int *) 0 ;
55265   char ***arg2 ;
55266   std::string *arg3 = 0 ;
55267   Dali::Application result;
55268
55269   {
55270     // Todo generate argv data from the C# args
55271     char **array;         // two dimensional array
55272     int numStrings = 1;     // number of strings
55273     int stringLength = 30;      // max string length.
55274     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55275     argV = array;
55276
55277     // allocate the string data
55278     for( int i=0; i < numStrings; i++)
55279     {
55280       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55281     }
55282     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55283
55284     strcpy( array[0], "dali-csharp-app");
55285
55286     arg1 = &argC;
55287     arg2 = &argV;
55288   }
55289   if (!jarg3) {
55290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55291     return 0;
55292   }
55293   std::string arg3_str(jarg3);
55294   arg3 = &arg3_str;
55295   {
55296     try {
55297       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55298     } catch (std::out_of_range& e) {
55299       {
55300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55301       };
55302     } catch (std::exception& e) {
55303       {
55304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55305       };
55306     } catch (...) {
55307       {
55308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55309       };
55310     }
55311   }
55312   jresult = new Dali::Application((const Dali::Application &)result);
55313
55314   //argout typemap for const std::string&
55315
55316   return jresult;
55317 }
55318
55319
55320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55321   void * jresult ;
55322   int *arg1 = (int *) 0 ;
55323   char ***arg2 ;
55324   std::string *arg3 = 0 ;
55325   Dali::Application::WINDOW_MODE arg4 ;
55326   Dali::Application result;
55327
55328   {
55329     // Todo generate argv data from the C# args
55330     char **array;         // two dimensional array
55331     int numStrings = 1;     // number of strings
55332     int stringLength = 30;      // max string length.
55333     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55334     argV = array;
55335
55336     // allocate the string data
55337     for( int i=0; i < numStrings; i++)
55338     {
55339       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55340     }
55341     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55342
55343     strcpy( array[0], "dali-csharp-app");
55344
55345     arg1 = &argC;
55346     arg2 = &argV;
55347   }
55348   if (!jarg3) {
55349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55350     return 0;
55351   }
55352   std::string arg3_str(jarg3);
55353   arg3 = &arg3_str;
55354   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55355   {
55356     try {
55357       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55358     } catch (std::out_of_range& e) {
55359       {
55360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55361       };
55362     } catch (std::exception& e) {
55363       {
55364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (...) {
55367       {
55368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55369       };
55370     }
55371   }
55372   jresult = new Dali::Application((const Dali::Application &)result);
55373
55374   //argout typemap for const std::string&
55375
55376   return jresult;
55377 }
55378
55379
55380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55381   void * jresult ;
55382   Dali::Application *result = 0 ;
55383
55384   {
55385     try {
55386       result = (Dali::Application *)new Dali::Application();
55387     } catch (std::out_of_range& e) {
55388       {
55389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (std::exception& e) {
55392       {
55393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55398       };
55399     }
55400   }
55401   jresult = (void *)result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55407   void * jresult ;
55408   Dali::Application *arg1 = 0 ;
55409   Dali::Application *result = 0 ;
55410
55411   arg1 = (Dali::Application *)jarg1;
55412   if (!arg1) {
55413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55414     return 0;
55415   }
55416   {
55417     try {
55418       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55419     } catch (std::out_of_range& e) {
55420       {
55421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (std::exception& e) {
55424       {
55425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55426       };
55427     } catch (...) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55430       };
55431     }
55432   }
55433   jresult = (void *)result;
55434   return jresult;
55435 }
55436
55437
55438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55439   void * jresult ;
55440   Dali::Application *arg1 = (Dali::Application *) 0 ;
55441   Dali::Application *arg2 = 0 ;
55442   Dali::Application *result = 0 ;
55443
55444   arg1 = (Dali::Application *)jarg1;
55445   arg2 = (Dali::Application *)jarg2;
55446   if (!arg2) {
55447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55448     return 0;
55449   }
55450   {
55451     try {
55452       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55453     } catch (std::out_of_range& e) {
55454       {
55455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55456       };
55457     } catch (std::exception& e) {
55458       {
55459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55460       };
55461     } catch (...) {
55462       {
55463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55464       };
55465     }
55466   }
55467   jresult = (void *)result;
55468   return jresult;
55469 }
55470
55471
55472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55473   Dali::Application *arg1 = (Dali::Application *) 0 ;
55474
55475   arg1 = (Dali::Application *)jarg1;
55476   {
55477     try {
55478       delete arg1;
55479     } catch (std::out_of_range& e) {
55480       {
55481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (std::exception& e) {
55484       {
55485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55490       };
55491     }
55492   }
55493 }
55494
55495
55496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55497   Dali::Application *arg1 = (Dali::Application *) 0 ;
55498
55499   arg1 = (Dali::Application *)jarg1;
55500   {
55501     try {
55502       (arg1)->MainLoop();
55503     } catch (std::out_of_range& e) {
55504       {
55505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55506       };
55507     } catch (std::exception& e) {
55508       {
55509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55510       };
55511     } catch (...) {
55512       {
55513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55514       };
55515     }
55516   }
55517 }
55518
55519
55520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55521   Dali::Application *arg1 = (Dali::Application *) 0 ;
55522   Configuration::ContextLoss arg2 ;
55523   Configuration::ContextLoss *argp2 ;
55524
55525   arg1 = (Dali::Application *)jarg1;
55526   argp2 = (Configuration::ContextLoss *)jarg2;
55527   if (!argp2) {
55528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55529     return ;
55530   }
55531   arg2 = *argp2;
55532   {
55533     try {
55534       (arg1)->MainLoop(arg2);
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55542       };
55543     } catch (...) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55546       };
55547     }
55548   }
55549 }
55550
55551
55552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55553   Dali::Application *arg1 = (Dali::Application *) 0 ;
55554
55555   arg1 = (Dali::Application *)jarg1;
55556   {
55557     try {
55558       (arg1)->Lower();
55559     } catch (std::out_of_range& e) {
55560       {
55561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55562       };
55563     } catch (std::exception& e) {
55564       {
55565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55566       };
55567     } catch (...) {
55568       {
55569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55570       };
55571     }
55572   }
55573 }
55574
55575
55576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55577   Dali::Application *arg1 = (Dali::Application *) 0 ;
55578
55579   arg1 = (Dali::Application *)jarg1;
55580   {
55581     try {
55582       (arg1)->Quit();
55583     } catch (std::out_of_range& e) {
55584       {
55585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55586       };
55587     } catch (std::exception& e) {
55588       {
55589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55590       };
55591     } catch (...) {
55592       {
55593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55594       };
55595     }
55596   }
55597 }
55598
55599
55600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55601   unsigned int jresult ;
55602   Dali::Application *arg1 = (Dali::Application *) 0 ;
55603   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55604   bool result;
55605
55606   arg1 = (Dali::Application *)jarg1;
55607   arg2 = (Dali::CallbackBase *)jarg2;
55608   {
55609     try {
55610       result = (bool)(arg1)->AddIdle(arg2);
55611     } catch (std::out_of_range& e) {
55612       {
55613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (std::exception& e) {
55616       {
55617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55618       };
55619     } catch (...) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55622       };
55623     }
55624   }
55625   jresult = result;
55626   return jresult;
55627 }
55628
55629
55630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55631   void * jresult ;
55632   Dali::Application *arg1 = (Dali::Application *) 0 ;
55633   Dali::Window result;
55634
55635   arg1 = (Dali::Application *)jarg1;
55636   {
55637     try {
55638       result = (arg1)->GetWindow();
55639     } catch (std::out_of_range& e) {
55640       {
55641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55642       };
55643     } catch (std::exception& e) {
55644       {
55645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55646       };
55647     } catch (...) {
55648       {
55649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55650       };
55651     }
55652   }
55653   jresult = new Dali::Window((const Dali::Window &)result);
55654   return jresult;
55655 }
55656
55657
55658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55659   Dali::Application *arg1 = (Dali::Application *) 0 ;
55660   Dali::PositionSize arg2 ;
55661   std::string *arg3 = 0 ;
55662   Dali::PositionSize *argp2 ;
55663
55664   arg1 = (Dali::Application *)jarg1;
55665   argp2 = (Dali::PositionSize *)jarg2;
55666   if (!argp2) {
55667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55668     return ;
55669   }
55670   arg2 = *argp2;
55671   if (!jarg3) {
55672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55673     return ;
55674   }
55675   std::string arg3_str(jarg3);
55676   arg3 = &arg3_str;
55677   {
55678     try {
55679       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55680     } catch (std::out_of_range& e) {
55681       {
55682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55683       };
55684     } catch (std::exception& e) {
55685       {
55686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55687       };
55688     } catch (...) {
55689       {
55690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55691       };
55692     }
55693   }
55694
55695   //argout typemap for const std::string&
55696
55697 }
55698
55699
55700 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55701   char * jresult ;
55702   std::string result;
55703
55704   {
55705     try {
55706       result = Dali::Application::GetResourcePath();
55707     } catch (std::out_of_range& e) {
55708       {
55709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55710       };
55711     } catch (std::exception& e) {
55712       {
55713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55714       };
55715     } catch (...) {
55716       {
55717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55718       };
55719     }
55720   }
55721   jresult = SWIG_csharp_string_callback((&result)->c_str());
55722   return jresult;
55723 }
55724
55725
55726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55727   Dali::Application *arg1 = (Dali::Application *) 0 ;
55728   Dali::ViewMode arg2 ;
55729
55730   arg1 = (Dali::Application *)jarg1;
55731   arg2 = (Dali::ViewMode)jarg2;
55732   {
55733     try {
55734       (arg1)->SetViewMode(arg2);
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55742       };
55743     } catch (...) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55746       };
55747     }
55748   }
55749 }
55750
55751
55752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55753   int jresult ;
55754   Dali::Application *arg1 = (Dali::Application *) 0 ;
55755   Dali::ViewMode result;
55756
55757   arg1 = (Dali::Application *)jarg1;
55758   {
55759     try {
55760       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55761     } catch (std::out_of_range& e) {
55762       {
55763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55764       };
55765     } catch (std::exception& e) {
55766       {
55767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55768       };
55769     } catch (...) {
55770       {
55771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55772       };
55773     }
55774   }
55775   jresult = (int)result;
55776   return jresult;
55777 }
55778
55779
55780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55781   Dali::Application *arg1 = (Dali::Application *) 0 ;
55782   float arg2 ;
55783
55784   arg1 = (Dali::Application *)jarg1;
55785   arg2 = (float)jarg2;
55786   {
55787     try {
55788       (arg1)->SetStereoBase(arg2);
55789     } catch (std::out_of_range& e) {
55790       {
55791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55792       };
55793     } catch (std::exception& e) {
55794       {
55795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55800       };
55801     }
55802   }
55803 }
55804
55805
55806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55807   float jresult ;
55808   Dali::Application *arg1 = (Dali::Application *) 0 ;
55809   float result;
55810
55811   arg1 = (Dali::Application *)jarg1;
55812   {
55813     try {
55814       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55815     } catch (std::out_of_range& e) {
55816       {
55817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55818       };
55819     } catch (std::exception& e) {
55820       {
55821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55826       };
55827     }
55828   }
55829   jresult = result;
55830   return jresult;
55831 }
55832
55833
55834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55835   void * jresult ;
55836   Dali::Application *arg1 = (Dali::Application *) 0 ;
55837   Dali::Application::AppSignalType *result = 0 ;
55838
55839   arg1 = (Dali::Application *)jarg1;
55840   {
55841     try {
55842       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55843     } catch (std::out_of_range& e) {
55844       {
55845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55846       };
55847     } catch (std::exception& e) {
55848       {
55849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55850       };
55851     } catch (...) {
55852       {
55853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55854       };
55855     }
55856   }
55857   jresult = (void *)result;
55858   return jresult;
55859 }
55860
55861
55862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55863   void * jresult ;
55864   Dali::Application *arg1 = (Dali::Application *) 0 ;
55865   Dali::Application::AppSignalType *result = 0 ;
55866
55867   arg1 = (Dali::Application *)jarg1;
55868   {
55869     try {
55870       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55871     } catch (std::out_of_range& e) {
55872       {
55873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55874       };
55875     } catch (std::exception& e) {
55876       {
55877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55878       };
55879     } catch (...) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55882       };
55883     }
55884   }
55885   jresult = (void *)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55891   void * jresult ;
55892   Dali::Application *arg1 = (Dali::Application *) 0 ;
55893   Dali::Application::AppSignalType *result = 0 ;
55894
55895   arg1 = (Dali::Application *)jarg1;
55896   {
55897     try {
55898       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55906       };
55907     } catch (...) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55910       };
55911     }
55912   }
55913   jresult = (void *)result;
55914   return jresult;
55915 }
55916
55917
55918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55919   void * jresult ;
55920   Dali::Application *arg1 = (Dali::Application *) 0 ;
55921   Dali::Application::AppSignalType *result = 0 ;
55922
55923   arg1 = (Dali::Application *)jarg1;
55924   {
55925     try {
55926       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55927     } catch (std::out_of_range& e) {
55928       {
55929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55930       };
55931     } catch (std::exception& e) {
55932       {
55933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55934       };
55935     } catch (...) {
55936       {
55937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55938       };
55939     }
55940   }
55941   jresult = (void *)result;
55942   return jresult;
55943 }
55944
55945
55946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55947   void * jresult ;
55948   Dali::Application *arg1 = (Dali::Application *) 0 ;
55949   Dali::Application::AppSignalType *result = 0 ;
55950
55951   arg1 = (Dali::Application *)jarg1;
55952   {
55953     try {
55954       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55955     } catch (std::out_of_range& e) {
55956       {
55957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55958       };
55959     } catch (std::exception& e) {
55960       {
55961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55962       };
55963     } catch (...) {
55964       {
55965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55966       };
55967     }
55968   }
55969   jresult = (void *)result;
55970   return jresult;
55971 }
55972
55973
55974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55975   void * jresult ;
55976   Dali::Application *arg1 = (Dali::Application *) 0 ;
55977   Dali::Application::AppSignalType *result = 0 ;
55978
55979   arg1 = (Dali::Application *)jarg1;
55980   {
55981     try {
55982       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55983     } catch (std::out_of_range& e) {
55984       {
55985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55986       };
55987     } catch (std::exception& e) {
55988       {
55989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55990       };
55991     } catch (...) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55994       };
55995     }
55996   }
55997   jresult = (void *)result;
55998   return jresult;
55999 }
56000
56001
56002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
56003   void * jresult ;
56004   Dali::Application *arg1 = (Dali::Application *) 0 ;
56005   Dali::Application::AppControlSignalType *result = 0 ;
56006
56007   arg1 = (Dali::Application *)jarg1;
56008   {
56009     try {
56010       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
56011     } catch (std::out_of_range& e) {
56012       {
56013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56014       };
56015     } catch (std::exception& e) {
56016       {
56017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56018       };
56019     } catch (...) {
56020       {
56021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56022       };
56023     }
56024   }
56025   jresult = (void *)result;
56026   return jresult;
56027 }
56028
56029
56030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
56031   void * jresult ;
56032   Dali::Application *arg1 = (Dali::Application *) 0 ;
56033   Dali::Application::AppSignalType *result = 0 ;
56034
56035   arg1 = (Dali::Application *)jarg1;
56036   {
56037     try {
56038       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56039     } catch (std::out_of_range& e) {
56040       {
56041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56042       };
56043     } catch (std::exception& e) {
56044       {
56045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56046       };
56047     } catch (...) {
56048       {
56049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56050       };
56051     }
56052   }
56053   jresult = (void *)result;
56054   return jresult;
56055 }
56056
56057
56058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
56059   void * jresult ;
56060   Dali::Application *arg1 = (Dali::Application *) 0 ;
56061   Dali::Application::AppSignalType *result = 0 ;
56062
56063   arg1 = (Dali::Application *)jarg1;
56064   {
56065     try {
56066       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56067     } catch (std::out_of_range& e) {
56068       {
56069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56070       };
56071     } catch (std::exception& e) {
56072       {
56073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (...) {
56076       {
56077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56078       };
56079     }
56080   }
56081   jresult = (void *)result;
56082   return jresult;
56083 }
56084
56085
56086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
56087   void * jresult ;
56088   Dali::Application *arg1 = (Dali::Application *) 0 ;
56089   Dali::Application::AppSignalType *result = 0 ;
56090
56091   arg1 = (Dali::Application *)jarg1;
56092   {
56093     try {
56094       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56095     } catch (std::out_of_range& e) {
56096       {
56097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56098       };
56099     } catch (std::exception& e) {
56100       {
56101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56102       };
56103     } catch (...) {
56104       {
56105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56106       };
56107     }
56108   }
56109   jresult = (void *)result;
56110   return jresult;
56111 }
56112
56113
56114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56115   void * jresult ;
56116   Dali::Application *arg1 = (Dali::Application *) 0 ;
56117   Dali::Application::AppSignalType *result = 0 ;
56118
56119   arg1 = (Dali::Application *)jarg1;
56120   {
56121     try {
56122       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56123     } catch (std::out_of_range& e) {
56124       {
56125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56126       };
56127     } catch (std::exception& e) {
56128       {
56129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (...) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56134       };
56135     }
56136   }
56137   jresult = (void *)result;
56138   return jresult;
56139 }
56140
56141
56142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56143   unsigned int jresult ;
56144   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56145   bool result;
56146
56147   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56148   {
56149     try {
56150       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56151     } catch (std::out_of_range& e) {
56152       {
56153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56154       };
56155     } catch (std::exception& e) {
56156       {
56157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56158       };
56159     } catch (...) {
56160       {
56161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56162       };
56163     }
56164   }
56165   jresult = result;
56166   return jresult;
56167 }
56168
56169
56170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56171   unsigned long jresult ;
56172   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56173   std::size_t result;
56174
56175   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56176   {
56177     try {
56178       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56179     } catch (std::out_of_range& e) {
56180       {
56181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56182       };
56183     } catch (std::exception& e) {
56184       {
56185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56186       };
56187     } catch (...) {
56188       {
56189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56190       };
56191     }
56192   }
56193   jresult = (unsigned long)result;
56194   return jresult;
56195 }
56196
56197
56198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56199   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56200   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56201
56202   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56203   arg2 = (void (*)(Dali::Application &))jarg2;
56204   {
56205     try {
56206       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56207     } catch (std::out_of_range& e) {
56208       {
56209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56210       };
56211     } catch (std::exception& e) {
56212       {
56213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56214       };
56215     } catch (...) {
56216       {
56217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56218       };
56219     }
56220   }
56221 }
56222
56223
56224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56225   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56226   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56227
56228   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56229   arg2 = (void (*)(Dali::Application &))jarg2;
56230   {
56231     try {
56232       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56233     } catch (std::out_of_range& e) {
56234       {
56235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56236       };
56237     } catch (std::exception& e) {
56238       {
56239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56240       };
56241     } catch (...) {
56242       {
56243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56244       };
56245     }
56246   }
56247 }
56248
56249
56250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56251   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56252   Dali::Application *arg2 = 0 ;
56253
56254   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56255   arg2 = (Dali::Application *)jarg2;
56256   if (!arg2) {
56257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56258     return ;
56259   }
56260   {
56261     try {
56262       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (...) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56274       };
56275     }
56276   }
56277 }
56278
56279
56280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56281   void * jresult ;
56282   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56283
56284   {
56285     try {
56286       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56287     } catch (std::out_of_range& e) {
56288       {
56289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (std::exception& e) {
56292       {
56293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (...) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56298       };
56299     }
56300   }
56301   jresult = (void *)result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56307   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56308
56309   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56310   {
56311     try {
56312       delete arg1;
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56320       };
56321     } catch (...) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56324       };
56325     }
56326   }
56327 }
56328
56329
56330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56331   unsigned int jresult ;
56332   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56333   bool result;
56334
56335   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56336   {
56337     try {
56338       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56339     } catch (std::out_of_range& e) {
56340       {
56341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (std::exception& e) {
56344       {
56345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56350       };
56351     }
56352   }
56353   jresult = result;
56354   return jresult;
56355 }
56356
56357
56358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56359   unsigned long jresult ;
56360   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56361   std::size_t result;
56362
56363   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56364   {
56365     try {
56366       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56374       };
56375     } catch (...) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56378       };
56379     }
56380   }
56381   jresult = (unsigned long)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56387   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56388   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56389
56390   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56391   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56392   {
56393     try {
56394       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56402       };
56403     } catch (...) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56406       };
56407     }
56408   }
56409 }
56410
56411
56412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56413   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56414   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56415
56416   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56417   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56418   {
56419     try {
56420       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56421     } catch (std::out_of_range& e) {
56422       {
56423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56424       };
56425     } catch (std::exception& e) {
56426       {
56427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56428       };
56429     } catch (...) {
56430       {
56431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56432       };
56433     }
56434   }
56435 }
56436
56437
56438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56439   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56440   Dali::Application *arg2 = 0 ;
56441   void *arg3 = (void *) 0 ;
56442
56443   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56444   arg2 = (Dali::Application *)jarg2;
56445   if (!arg2) {
56446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56447     return ;
56448   }
56449   arg3 = jarg3;
56450   {
56451     try {
56452       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56460       };
56461     } catch (...) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56464       };
56465     }
56466   }
56467 }
56468
56469
56470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56471   void * jresult ;
56472   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56473
56474   {
56475     try {
56476       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56477     } catch (std::out_of_range& e) {
56478       {
56479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56480       };
56481     } catch (std::exception& e) {
56482       {
56483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56484       };
56485     } catch (...) {
56486       {
56487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56488       };
56489     }
56490   }
56491   jresult = (void *)result;
56492   return jresult;
56493 }
56494
56495
56496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56497   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56498
56499   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56500   {
56501     try {
56502       delete arg1;
56503     } catch (std::out_of_range& e) {
56504       {
56505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56506       };
56507     } catch (std::exception& e) {
56508       {
56509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56510       };
56511     } catch (...) {
56512       {
56513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56514       };
56515     }
56516   }
56517 }
56518
56519
56520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56521   unsigned int jresult ;
56522   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56523   bool result;
56524
56525   arg1 = (Dali::Signal< bool () > *)jarg1;
56526   {
56527     try {
56528       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56529     } catch (std::out_of_range& e) {
56530       {
56531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56532       };
56533     } catch (std::exception& e) {
56534       {
56535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56536       };
56537     } catch (...) {
56538       {
56539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56540       };
56541     }
56542   }
56543   jresult = result;
56544   return jresult;
56545 }
56546
56547
56548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56549   unsigned long jresult ;
56550   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56551   std::size_t result;
56552
56553   arg1 = (Dali::Signal< bool () > *)jarg1;
56554   {
56555     try {
56556       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56557     } catch (std::out_of_range& e) {
56558       {
56559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56560       };
56561     } catch (std::exception& e) {
56562       {
56563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (...) {
56566       {
56567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56568       };
56569     }
56570   }
56571   jresult = (unsigned long)result;
56572   return jresult;
56573 }
56574
56575
56576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56577   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56578   bool (*arg2)() = (bool (*)()) 0 ;
56579
56580   arg1 = (Dali::Signal< bool () > *)jarg1;
56581   arg2 = (bool (*)())jarg2;
56582   {
56583     try {
56584       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56592       };
56593     } catch (...) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56596       };
56597     }
56598   }
56599 }
56600
56601
56602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56603   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56604   bool (*arg2)() = (bool (*)()) 0 ;
56605
56606   arg1 = (Dali::Signal< bool () > *)jarg1;
56607   arg2 = (bool (*)())jarg2;
56608   {
56609     try {
56610       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56611     } catch (std::out_of_range& e) {
56612       {
56613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (std::exception& e) {
56616       {
56617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56618       };
56619     } catch (...) {
56620       {
56621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56622       };
56623     }
56624   }
56625 }
56626
56627
56628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56629   unsigned int jresult ;
56630   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56631   bool result;
56632
56633   arg1 = (Dali::Signal< bool () > *)jarg1;
56634   {
56635     try {
56636       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56637     } catch (std::out_of_range& e) {
56638       {
56639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56640       };
56641     } catch (std::exception& e) {
56642       {
56643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (...) {
56646       {
56647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56648       };
56649     }
56650   }
56651   jresult = result;
56652   return jresult;
56653 }
56654
56655
56656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56657   void * jresult ;
56658   Dali::Signal< bool () > *result = 0 ;
56659
56660   {
56661     try {
56662       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56663     } catch (std::out_of_range& e) {
56664       {
56665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56666       };
56667     } catch (std::exception& e) {
56668       {
56669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56670       };
56671     } catch (...) {
56672       {
56673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56674       };
56675     }
56676   }
56677   jresult = (void *)result;
56678   return jresult;
56679 }
56680
56681
56682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56683   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56684
56685   arg1 = (Dali::Signal< bool () > *)jarg1;
56686   {
56687     try {
56688       delete arg1;
56689     } catch (std::out_of_range& e) {
56690       {
56691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56692       };
56693     } catch (std::exception& e) {
56694       {
56695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56696       };
56697     } catch (...) {
56698       {
56699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56700       };
56701     }
56702   }
56703 }
56704
56705
56706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56707   unsigned int jresult ;
56708   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56709   bool result;
56710
56711   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56712   {
56713     try {
56714       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56715     } catch (std::out_of_range& e) {
56716       {
56717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56718       };
56719     } catch (std::exception& e) {
56720       {
56721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56722       };
56723     } catch (...) {
56724       {
56725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56726       };
56727     }
56728   }
56729   jresult = result;
56730   return jresult;
56731 }
56732
56733
56734 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56735   unsigned long jresult ;
56736   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56737   std::size_t result;
56738
56739   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56740   {
56741     try {
56742       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56743     } catch (std::out_of_range& e) {
56744       {
56745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (std::exception& e) {
56748       {
56749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757   jresult = (unsigned long)result;
56758   return jresult;
56759 }
56760
56761
56762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56763   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56764   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56765
56766   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56767   arg2 = (void (*)(bool))jarg2;
56768   {
56769     try {
56770       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56782       };
56783     }
56784   }
56785 }
56786
56787
56788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56789   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56790   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56791
56792   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56793   arg2 = (void (*)(bool))jarg2;
56794   {
56795     try {
56796       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56797     } catch (std::out_of_range& e) {
56798       {
56799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56800       };
56801     } catch (std::exception& e) {
56802       {
56803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56804       };
56805     } catch (...) {
56806       {
56807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56808       };
56809     }
56810   }
56811 }
56812
56813
56814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56815   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56816   bool arg2 ;
56817
56818   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56819   arg2 = jarg2 ? true : false;
56820   {
56821     try {
56822       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56823     } catch (std::out_of_range& e) {
56824       {
56825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56826       };
56827     } catch (std::exception& e) {
56828       {
56829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56830       };
56831     } catch (...) {
56832       {
56833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56834       };
56835     }
56836   }
56837 }
56838
56839
56840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56841   void * jresult ;
56842   Dali::Signal< void (bool) > *result = 0 ;
56843
56844   {
56845     try {
56846       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56847     } catch (std::out_of_range& e) {
56848       {
56849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56850       };
56851     } catch (std::exception& e) {
56852       {
56853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56854       };
56855     } catch (...) {
56856       {
56857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56858       };
56859     }
56860   }
56861   jresult = (void *)result;
56862   return jresult;
56863 }
56864
56865
56866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56867   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56868
56869   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56870   {
56871     try {
56872       delete arg1;
56873     } catch (std::out_of_range& e) {
56874       {
56875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56876       };
56877     } catch (std::exception& e) {
56878       {
56879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56880       };
56881     } catch (...) {
56882       {
56883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56884       };
56885     }
56886   }
56887 }
56888
56889
56890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56891   int jresult ;
56892   int result;
56893
56894   {
56895     try {
56896       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56897     } catch (std::out_of_range& e) {
56898       {
56899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56900       };
56901     } catch (std::exception& e) {
56902       {
56903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56904       };
56905     } catch (...) {
56906       {
56907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56908       };
56909     }
56910   }
56911   jresult = (int)result;
56912   return jresult;
56913 }
56914
56915
56916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56917   int jresult ;
56918   int result;
56919
56920   {
56921     try {
56922       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56923     } catch (std::out_of_range& e) {
56924       {
56925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56926       };
56927     } catch (std::exception& e) {
56928       {
56929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (...) {
56932       {
56933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56934       };
56935     }
56936   }
56937   jresult = (int)result;
56938   return jresult;
56939 }
56940
56941
56942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56943   int jresult ;
56944   int result;
56945
56946   {
56947     try {
56948       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56949     } catch (std::out_of_range& e) {
56950       {
56951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56952       };
56953     } catch (std::exception& e) {
56954       {
56955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (...) {
56958       {
56959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56960       };
56961     }
56962   }
56963   jresult = (int)result;
56964   return jresult;
56965 }
56966
56967
56968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56969   int jresult ;
56970   int result;
56971
56972   {
56973     try {
56974       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56975     } catch (std::out_of_range& e) {
56976       {
56977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56978       };
56979     } catch (std::exception& e) {
56980       {
56981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (...) {
56984       {
56985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56986       };
56987     }
56988   }
56989   jresult = (int)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56995   int jresult ;
56996   int result;
56997
56998   {
56999     try {
57000       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (...) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57012       };
57013     }
57014   }
57015   jresult = (int)result;
57016   return jresult;
57017 }
57018
57019
57020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
57021   int jresult ;
57022   int result;
57023
57024   {
57025     try {
57026       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (...) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57038       };
57039     }
57040   }
57041   jresult = (int)result;
57042   return jresult;
57043 }
57044
57045
57046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57047   int jresult ;
57048   int result;
57049
57050   {
57051     try {
57052       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57053     } catch (std::out_of_range& e) {
57054       {
57055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57056       };
57057     } catch (std::exception& e) {
57058       {
57059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57060       };
57061     } catch (...) {
57062       {
57063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57064       };
57065     }
57066   }
57067   jresult = (int)result;
57068   return jresult;
57069 }
57070
57071
57072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57073   int jresult ;
57074   int result;
57075
57076   {
57077     try {
57078       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57079     } catch (std::out_of_range& e) {
57080       {
57081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57082       };
57083     } catch (std::exception& e) {
57084       {
57085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (...) {
57088       {
57089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57090       };
57091     }
57092   }
57093   jresult = (int)result;
57094   return jresult;
57095 }
57096
57097
57098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57099   int jresult ;
57100   int result;
57101
57102   {
57103     try {
57104       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57105     } catch (std::out_of_range& e) {
57106       {
57107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57108       };
57109     } catch (std::exception& e) {
57110       {
57111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57112       };
57113     } catch (...) {
57114       {
57115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57116       };
57117     }
57118   }
57119   jresult = (int)result;
57120   return jresult;
57121 }
57122
57123
57124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57125   int jresult ;
57126   int result;
57127
57128   {
57129     try {
57130       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57131     } catch (std::out_of_range& e) {
57132       {
57133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57134       };
57135     } catch (std::exception& e) {
57136       {
57137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (...) {
57140       {
57141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57142       };
57143     }
57144   }
57145   jresult = (int)result;
57146   return jresult;
57147 }
57148
57149
57150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57151   int jresult ;
57152   int result;
57153
57154   {
57155     try {
57156       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57157     } catch (std::out_of_range& e) {
57158       {
57159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57160       };
57161     } catch (std::exception& e) {
57162       {
57163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57164       };
57165     } catch (...) {
57166       {
57167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57168       };
57169     }
57170   }
57171   jresult = (int)result;
57172   return jresult;
57173 }
57174
57175
57176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57177   int jresult ;
57178   int result;
57179
57180   {
57181     try {
57182       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57183     } catch (std::out_of_range& e) {
57184       {
57185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57186       };
57187     } catch (std::exception& e) {
57188       {
57189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (...) {
57192       {
57193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57194       };
57195     }
57196   }
57197   jresult = (int)result;
57198   return jresult;
57199 }
57200
57201
57202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57203   int jresult ;
57204   int result;
57205
57206   {
57207     try {
57208       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57209     } catch (std::out_of_range& e) {
57210       {
57211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (std::exception& e) {
57214       {
57215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223   jresult = (int)result;
57224   return jresult;
57225 }
57226
57227
57228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57229   int jresult ;
57230   int result;
57231
57232   {
57233     try {
57234       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57235     } catch (std::out_of_range& e) {
57236       {
57237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57238       };
57239     } catch (std::exception& e) {
57240       {
57241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57242       };
57243     } catch (...) {
57244       {
57245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57246       };
57247     }
57248   }
57249   jresult = (int)result;
57250   return jresult;
57251 }
57252
57253
57254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57255   int jresult ;
57256   int result;
57257
57258   {
57259     try {
57260       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (...) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57272       };
57273     }
57274   }
57275   jresult = (int)result;
57276   return jresult;
57277 }
57278
57279
57280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57281   int jresult ;
57282   int result;
57283
57284   {
57285     try {
57286       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57287     } catch (std::out_of_range& e) {
57288       {
57289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57290       };
57291     } catch (std::exception& e) {
57292       {
57293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57294       };
57295     } catch (...) {
57296       {
57297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57298       };
57299     }
57300   }
57301   jresult = (int)result;
57302   return jresult;
57303 }
57304
57305
57306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57307   int jresult ;
57308   int result;
57309
57310   {
57311     try {
57312       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57313     } catch (std::out_of_range& e) {
57314       {
57315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57316       };
57317     } catch (std::exception& e) {
57318       {
57319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (...) {
57322       {
57323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57324       };
57325     }
57326   }
57327   jresult = (int)result;
57328   return jresult;
57329 }
57330
57331
57332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57333   int jresult ;
57334   int result;
57335
57336   {
57337     try {
57338       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57339     } catch (std::out_of_range& e) {
57340       {
57341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57342       };
57343     } catch (std::exception& e) {
57344       {
57345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57346       };
57347     } catch (...) {
57348       {
57349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57350       };
57351     }
57352   }
57353   jresult = (int)result;
57354   return jresult;
57355 }
57356
57357
57358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57359   int jresult ;
57360   int result;
57361
57362   {
57363     try {
57364       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57365     } catch (std::out_of_range& e) {
57366       {
57367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (std::exception& e) {
57370       {
57371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57372       };
57373     } catch (...) {
57374       {
57375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57376       };
57377     }
57378   }
57379   jresult = (int)result;
57380   return jresult;
57381 }
57382
57383
57384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57385   int jresult ;
57386   int result;
57387
57388   {
57389     try {
57390       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57391     } catch (std::out_of_range& e) {
57392       {
57393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57394       };
57395     } catch (std::exception& e) {
57396       {
57397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57398       };
57399     } catch (...) {
57400       {
57401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57402       };
57403     }
57404   }
57405   jresult = (int)result;
57406   return jresult;
57407 }
57408
57409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57410   int jresult ;
57411   int result;
57412
57413   {
57414     try {
57415       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
57416     } catch (std::out_of_range& e) {
57417       {
57418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (std::exception& e) {
57421       {
57422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430   jresult = (int)result;
57431   return jresult;
57432 }
57433
57434
57435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57436   int jresult ;
57437   int result;
57438
57439   {
57440     try {
57441       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57442     } catch (std::out_of_range& e) {
57443       {
57444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57445       };
57446     } catch (std::exception& e) {
57447       {
57448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57449       };
57450     } catch (...) {
57451       {
57452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57453       };
57454     }
57455   }
57456   jresult = (int)result;
57457   return jresult;
57458 }
57459
57460
57461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57462   int jresult ;
57463   int result;
57464
57465   {
57466     try {
57467       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57468     } catch (std::out_of_range& e) {
57469       {
57470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57471       };
57472     } catch (std::exception& e) {
57473       {
57474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57475       };
57476     } catch (...) {
57477       {
57478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57479       };
57480     }
57481   }
57482   jresult = (int)result;
57483   return jresult;
57484 }
57485
57486
57487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57488   int jresult ;
57489   int result;
57490
57491   {
57492     try {
57493       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57505       };
57506     }
57507   }
57508   jresult = (int)result;
57509   return jresult;
57510 }
57511
57512
57513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57514   int jresult ;
57515   int result;
57516
57517   {
57518     try {
57519       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (...) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57531       };
57532     }
57533   }
57534   jresult = (int)result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57540   int jresult ;
57541   int result;
57542
57543   {
57544     try {
57545       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57546     } catch (std::out_of_range& e) {
57547       {
57548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57549       };
57550     } catch (std::exception& e) {
57551       {
57552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57553       };
57554     } catch (...) {
57555       {
57556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57557       };
57558     }
57559   }
57560   jresult = (int)result;
57561   return jresult;
57562 }
57563
57564
57565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57566   int jresult ;
57567   int result;
57568
57569   {
57570     try {
57571       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57572     } catch (std::out_of_range& e) {
57573       {
57574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57575       };
57576     } catch (std::exception& e) {
57577       {
57578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57579       };
57580     } catch (...) {
57581       {
57582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57583       };
57584     }
57585   }
57586   jresult = (int)result;
57587   return jresult;
57588 }
57589
57590
57591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57592   int jresult ;
57593   int result;
57594
57595   {
57596     try {
57597       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57598     } catch (std::out_of_range& e) {
57599       {
57600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (std::exception& e) {
57603       {
57604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57609       };
57610     }
57611   }
57612   jresult = (int)result;
57613   return jresult;
57614 }
57615
57616
57617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57618   int jresult ;
57619   int result;
57620
57621   {
57622     try {
57623       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57624     } catch (std::out_of_range& e) {
57625       {
57626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (std::exception& e) {
57629       {
57630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57635       };
57636     }
57637   }
57638   jresult = (int)result;
57639   return jresult;
57640 }
57641
57642
57643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57644   int jresult ;
57645   int result;
57646
57647   {
57648     try {
57649       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57650     } catch (std::out_of_range& e) {
57651       {
57652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57653       };
57654     } catch (std::exception& e) {
57655       {
57656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (...) {
57659       {
57660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57661       };
57662     }
57663   }
57664   jresult = (int)result;
57665   return jresult;
57666 }
57667
57668
57669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57670   int jresult ;
57671   int result;
57672
57673   {
57674     try {
57675       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57676     } catch (std::out_of_range& e) {
57677       {
57678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57679       };
57680     } catch (std::exception& e) {
57681       {
57682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57687       };
57688     }
57689   }
57690   jresult = (int)result;
57691   return jresult;
57692 }
57693
57694
57695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57696   int jresult ;
57697   int result;
57698
57699   {
57700     try {
57701       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57702     } catch (std::out_of_range& e) {
57703       {
57704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57705       };
57706     } catch (std::exception& e) {
57707       {
57708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (...) {
57711       {
57712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57713       };
57714     }
57715   }
57716   jresult = (int)result;
57717   return jresult;
57718 }
57719
57720
57721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57722   int jresult ;
57723   int result;
57724
57725   {
57726     try {
57727       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57728     } catch (std::out_of_range& e) {
57729       {
57730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57731       };
57732     } catch (std::exception& e) {
57733       {
57734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57739       };
57740     }
57741   }
57742   jresult = (int)result;
57743   return jresult;
57744 }
57745
57746
57747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57748   int jresult ;
57749   int result;
57750
57751   {
57752     try {
57753       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57765       };
57766     }
57767   }
57768   jresult = (int)result;
57769   return jresult;
57770 }
57771
57772
57773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57774   int jresult ;
57775   int result;
57776
57777   {
57778     try {
57779       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57791       };
57792     }
57793   }
57794   jresult = (int)result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57800   int jresult ;
57801   int result;
57802
57803   {
57804     try {
57805       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57806     } catch (std::out_of_range& e) {
57807       {
57808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57809       };
57810     } catch (std::exception& e) {
57811       {
57812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57813       };
57814     } catch (...) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57817       };
57818     }
57819   }
57820   jresult = (int)result;
57821   return jresult;
57822 }
57823
57824
57825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57826   int jresult ;
57827   int result;
57828
57829   {
57830     try {
57831       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (...) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57843       };
57844     }
57845   }
57846   jresult = (int)result;
57847   return jresult;
57848 }
57849
57850
57851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57852   int jresult ;
57853   int result;
57854
57855   {
57856     try {
57857       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57858     } catch (std::out_of_range& e) {
57859       {
57860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (std::exception& e) {
57863       {
57864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57865       };
57866     } catch (...) {
57867       {
57868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57869       };
57870     }
57871   }
57872   jresult = (int)result;
57873   return jresult;
57874 }
57875
57876
57877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57878   int jresult ;
57879   int result;
57880
57881   {
57882     try {
57883       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (...) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57895       };
57896     }
57897   }
57898   jresult = (int)result;
57899   return jresult;
57900 }
57901
57902
57903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57904   int jresult ;
57905   int result;
57906
57907   {
57908     try {
57909       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57910     } catch (std::out_of_range& e) {
57911       {
57912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57913       };
57914     } catch (std::exception& e) {
57915       {
57916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57917       };
57918     } catch (...) {
57919       {
57920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57921       };
57922     }
57923   }
57924   jresult = (int)result;
57925   return jresult;
57926 }
57927
57928
57929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57930   int jresult ;
57931   int result;
57932
57933   {
57934     try {
57935       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57936     } catch (std::out_of_range& e) {
57937       {
57938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57939       };
57940     } catch (std::exception& e) {
57941       {
57942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (...) {
57945       {
57946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57947       };
57948     }
57949   }
57950   jresult = (int)result;
57951   return jresult;
57952 }
57953
57954
57955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57956   int jresult ;
57957   int result;
57958
57959   {
57960     try {
57961       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57962     } catch (std::out_of_range& e) {
57963       {
57964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (std::exception& e) {
57967       {
57968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976   jresult = (int)result;
57977   return jresult;
57978 }
57979
57980
57981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57982   int jresult ;
57983   int result;
57984
57985   {
57986     try {
57987       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57999       };
58000     }
58001   }
58002   jresult = (int)result;
58003   return jresult;
58004 }
58005
58006
58007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
58008   int jresult ;
58009   int result;
58010
58011   {
58012     try {
58013       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58014     } catch (std::out_of_range& e) {
58015       {
58016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58017       };
58018     } catch (std::exception& e) {
58019       {
58020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58021       };
58022     } catch (...) {
58023       {
58024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58025       };
58026     }
58027   }
58028   jresult = (int)result;
58029   return jresult;
58030 }
58031
58032
58033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58034   int jresult ;
58035   int result;
58036
58037   {
58038     try {
58039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58040     } catch (std::out_of_range& e) {
58041       {
58042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58043       };
58044     } catch (std::exception& e) {
58045       {
58046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58047       };
58048     } catch (...) {
58049       {
58050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58051       };
58052     }
58053   }
58054   jresult = (int)result;
58055   return jresult;
58056 }
58057
58058
58059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58060   int jresult ;
58061   int result;
58062
58063   {
58064     try {
58065       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58066     } catch (std::out_of_range& e) {
58067       {
58068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58069       };
58070     } catch (std::exception& e) {
58071       {
58072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (...) {
58075       {
58076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58077       };
58078     }
58079   }
58080   jresult = (int)result;
58081   return jresult;
58082 }
58083
58084
58085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58086   int jresult ;
58087   int result;
58088
58089   {
58090     try {
58091       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58092     } catch (std::out_of_range& e) {
58093       {
58094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58095       };
58096     } catch (std::exception& e) {
58097       {
58098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58099       };
58100     } catch (...) {
58101       {
58102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58103       };
58104     }
58105   }
58106   jresult = (int)result;
58107   return jresult;
58108 }
58109
58110
58111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58112   int jresult ;
58113   int result;
58114
58115   {
58116     try {
58117       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58118     } catch (std::out_of_range& e) {
58119       {
58120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58121       };
58122     } catch (std::exception& e) {
58123       {
58124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58125       };
58126     } catch (...) {
58127       {
58128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58129       };
58130     }
58131   }
58132   jresult = (int)result;
58133   return jresult;
58134 }
58135
58136
58137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58138   int jresult ;
58139   int result;
58140
58141   {
58142     try {
58143       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58144     } catch (std::out_of_range& e) {
58145       {
58146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58147       };
58148     } catch (std::exception& e) {
58149       {
58150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58151       };
58152     } catch (...) {
58153       {
58154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58155       };
58156     }
58157   }
58158   jresult = (int)result;
58159   return jresult;
58160 }
58161
58162
58163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58164   int jresult ;
58165   int result;
58166
58167   {
58168     try {
58169       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184   jresult = (int)result;
58185   return jresult;
58186 }
58187
58188
58189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58190   int jresult ;
58191   int result;
58192
58193   {
58194     try {
58195       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58196     } catch (std::out_of_range& e) {
58197       {
58198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58199       };
58200     } catch (std::exception& e) {
58201       {
58202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58203       };
58204     } catch (...) {
58205       {
58206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58207       };
58208     }
58209   }
58210   jresult = (int)result;
58211   return jresult;
58212 }
58213
58214
58215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58216   int jresult ;
58217   int result;
58218
58219   {
58220     try {
58221       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (...) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58233       };
58234     }
58235   }
58236   jresult = (int)result;
58237   return jresult;
58238 }
58239
58240
58241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58242   int jresult ;
58243   int result;
58244
58245   {
58246     try {
58247       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58248     } catch (std::out_of_range& e) {
58249       {
58250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58251       };
58252     } catch (std::exception& e) {
58253       {
58254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (...) {
58257       {
58258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58259       };
58260     }
58261   }
58262   jresult = (int)result;
58263   return jresult;
58264 }
58265
58266
58267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58268   int jresult ;
58269   int result;
58270
58271   {
58272     try {
58273       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58274     } catch (std::out_of_range& e) {
58275       {
58276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58277       };
58278     } catch (std::exception& e) {
58279       {
58280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (...) {
58283       {
58284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58285       };
58286     }
58287   }
58288   jresult = (int)result;
58289   return jresult;
58290 }
58291
58292
58293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58294   int jresult ;
58295   int result;
58296
58297   {
58298     try {
58299       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58300     } catch (std::out_of_range& e) {
58301       {
58302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (std::exception& e) {
58305       {
58306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314   jresult = (int)result;
58315   return jresult;
58316 }
58317
58318
58319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58320   int jresult ;
58321   int result;
58322
58323   {
58324     try {
58325       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58326     } catch (std::out_of_range& e) {
58327       {
58328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58329       };
58330     } catch (std::exception& e) {
58331       {
58332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58333       };
58334     } catch (...) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58337       };
58338     }
58339   }
58340   jresult = (int)result;
58341   return jresult;
58342 }
58343
58344
58345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58346   int jresult ;
58347   int result;
58348
58349   {
58350     try {
58351       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58352     } catch (std::out_of_range& e) {
58353       {
58354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58355       };
58356     } catch (std::exception& e) {
58357       {
58358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58359       };
58360     } catch (...) {
58361       {
58362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58363       };
58364     }
58365   }
58366   jresult = (int)result;
58367   return jresult;
58368 }
58369
58370
58371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58372   int jresult ;
58373   int result;
58374
58375   {
58376     try {
58377       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58378     } catch (std::out_of_range& e) {
58379       {
58380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58381       };
58382     } catch (std::exception& e) {
58383       {
58384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (...) {
58387       {
58388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58389       };
58390     }
58391   }
58392   jresult = (int)result;
58393   return jresult;
58394 }
58395
58396
58397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58398   void * jresult ;
58399   Dali::Toolkit::Builder *result = 0 ;
58400
58401   {
58402     try {
58403       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58404     } catch (std::out_of_range& e) {
58405       {
58406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58407       };
58408     } catch (std::exception& e) {
58409       {
58410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58411       };
58412     } catch (...) {
58413       {
58414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58415       };
58416     }
58417   }
58418   jresult = (void *)result;
58419   return jresult;
58420 }
58421
58422
58423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58424   void * jresult ;
58425   Dali::Toolkit::Builder result;
58426
58427   {
58428     try {
58429       result = Dali::Toolkit::Builder::New();
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (...) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58441       };
58442     }
58443   }
58444   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58445   return jresult;
58446 }
58447
58448
58449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58451
58452   arg1 = (Dali::Toolkit::Builder *)jarg1;
58453   {
58454     try {
58455       delete arg1;
58456     } catch (std::out_of_range& e) {
58457       {
58458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58459       };
58460     } catch (std::exception& e) {
58461       {
58462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58463       };
58464     } catch (...) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58467       };
58468     }
58469   }
58470 }
58471
58472
58473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58475   std::string *arg2 = 0 ;
58476   Dali::Toolkit::Builder::UIFormat arg3 ;
58477
58478   arg1 = (Dali::Toolkit::Builder *)jarg1;
58479   if (!jarg2) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58481     return ;
58482   }
58483   std::string arg2_str(jarg2);
58484   arg2 = &arg2_str;
58485   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58486   {
58487     try {
58488       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58489     } catch (std::out_of_range& e) {
58490       {
58491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58492       };
58493     } catch (std::exception& e) {
58494       {
58495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58496       };
58497     } catch (...) {
58498       {
58499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58500       };
58501     }
58502   }
58503
58504   //argout typemap for const std::string&
58505
58506 }
58507
58508
58509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58510   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58511   std::string *arg2 = 0 ;
58512
58513   arg1 = (Dali::Toolkit::Builder *)jarg1;
58514   if (!jarg2) {
58515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58516     return ;
58517   }
58518   std::string arg2_str(jarg2);
58519   arg2 = &arg2_str;
58520   {
58521     try {
58522       (arg1)->LoadFromString((std::string const &)*arg2);
58523     } catch (std::out_of_range& e) {
58524       {
58525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58526       };
58527     } catch (std::exception& e) {
58528       {
58529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58534       };
58535     }
58536   }
58537
58538   //argout typemap for const std::string&
58539
58540 }
58541
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58544   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58545   Dali::Property::Map *arg2 = 0 ;
58546
58547   arg1 = (Dali::Toolkit::Builder *)jarg1;
58548   arg2 = (Dali::Property::Map *)jarg2;
58549   if (!arg2) {
58550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58551     return ;
58552   }
58553   {
58554     try {
58555       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58556     } catch (std::out_of_range& e) {
58557       {
58558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58559       };
58560     } catch (std::exception& e) {
58561       {
58562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58567       };
58568     }
58569   }
58570 }
58571
58572
58573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58574   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58575   std::string *arg2 = 0 ;
58576   Dali::Property::Value *arg3 = 0 ;
58577
58578   arg1 = (Dali::Toolkit::Builder *)jarg1;
58579   if (!jarg2) {
58580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58581     return ;
58582   }
58583   std::string arg2_str(jarg2);
58584   arg2 = &arg2_str;
58585   arg3 = (Dali::Property::Value *)jarg3;
58586   if (!arg3) {
58587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58588     return ;
58589   }
58590   {
58591     try {
58592       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58593     } catch (std::out_of_range& e) {
58594       {
58595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58596       };
58597     } catch (std::exception& e) {
58598       {
58599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (...) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58604       };
58605     }
58606   }
58607
58608   //argout typemap for const std::string&
58609
58610 }
58611
58612
58613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58614   void * jresult ;
58615   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58616   Dali::Property::Map *result = 0 ;
58617
58618   arg1 = (Dali::Toolkit::Builder *)jarg1;
58619   {
58620     try {
58621       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58622     } catch (std::out_of_range& e) {
58623       {
58624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58625       };
58626     } catch (std::exception& e) {
58627       {
58628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58629       };
58630     } catch (...) {
58631       {
58632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58633       };
58634     }
58635   }
58636   jresult = (void *)result;
58637   return jresult;
58638 }
58639
58640
58641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58642   void * jresult ;
58643   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58644   std::string *arg2 = 0 ;
58645   Dali::Property::Value *result = 0 ;
58646
58647   arg1 = (Dali::Toolkit::Builder *)jarg1;
58648   if (!jarg2) {
58649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58650     return 0;
58651   }
58652   std::string arg2_str(jarg2);
58653   arg2 = &arg2_str;
58654   {
58655     try {
58656       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58657     } catch (std::out_of_range& e) {
58658       {
58659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (std::exception& e) {
58662       {
58663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58664       };
58665     } catch (...) {
58666       {
58667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58668       };
58669     }
58670   }
58671   jresult = (void *)result;
58672
58673   //argout typemap for const std::string&
58674
58675   return jresult;
58676 }
58677
58678
58679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58680   void * jresult ;
58681   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58682   std::string *arg2 = 0 ;
58683   Dali::Animation result;
58684
58685   arg1 = (Dali::Toolkit::Builder *)jarg1;
58686   if (!jarg2) {
58687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58688     return 0;
58689   }
58690   std::string arg2_str(jarg2);
58691   arg2 = &arg2_str;
58692   {
58693     try {
58694       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709   jresult = new Dali::Animation((const Dali::Animation &)result);
58710
58711   //argout typemap for const std::string&
58712
58713   return jresult;
58714 }
58715
58716
58717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58718   void * jresult ;
58719   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58720   std::string *arg2 = 0 ;
58721   Dali::Property::Map *arg3 = 0 ;
58722   Dali::Animation result;
58723
58724   arg1 = (Dali::Toolkit::Builder *)jarg1;
58725   if (!jarg2) {
58726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58727     return 0;
58728   }
58729   std::string arg2_str(jarg2);
58730   arg2 = &arg2_str;
58731   arg3 = (Dali::Property::Map *)jarg3;
58732   if (!arg3) {
58733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58734     return 0;
58735   }
58736   {
58737     try {
58738       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58739     } catch (std::out_of_range& e) {
58740       {
58741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58742       };
58743     } catch (std::exception& e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (...) {
58748       {
58749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58750       };
58751     }
58752   }
58753   jresult = new Dali::Animation((const Dali::Animation &)result);
58754
58755   //argout typemap for const std::string&
58756
58757   return jresult;
58758 }
58759
58760
58761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58762   void * jresult ;
58763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58764   std::string *arg2 = 0 ;
58765   Dali::Actor arg3 ;
58766   Dali::Actor *argp3 ;
58767   Dali::Animation result;
58768
58769   arg1 = (Dali::Toolkit::Builder *)jarg1;
58770   if (!jarg2) {
58771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58772     return 0;
58773   }
58774   std::string arg2_str(jarg2);
58775   arg2 = &arg2_str;
58776   argp3 = (Dali::Actor *)jarg3;
58777   if (!argp3) {
58778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58779     return 0;
58780   }
58781   arg3 = *argp3;
58782   {
58783     try {
58784       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58785     } catch (std::out_of_range& e) {
58786       {
58787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58788       };
58789     } catch (std::exception& e) {
58790       {
58791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58792       };
58793     } catch (...) {
58794       {
58795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58796       };
58797     }
58798   }
58799   jresult = new Dali::Animation((const Dali::Animation &)result);
58800
58801   //argout typemap for const std::string&
58802
58803   return jresult;
58804 }
58805
58806
58807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58808   void * jresult ;
58809   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58810   std::string *arg2 = 0 ;
58811   Dali::Property::Map *arg3 = 0 ;
58812   Dali::Actor arg4 ;
58813   Dali::Actor *argp4 ;
58814   Dali::Animation result;
58815
58816   arg1 = (Dali::Toolkit::Builder *)jarg1;
58817   if (!jarg2) {
58818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58819     return 0;
58820   }
58821   std::string arg2_str(jarg2);
58822   arg2 = &arg2_str;
58823   arg3 = (Dali::Property::Map *)jarg3;
58824   if (!arg3) {
58825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58826     return 0;
58827   }
58828   argp4 = (Dali::Actor *)jarg4;
58829   if (!argp4) {
58830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58831     return 0;
58832   }
58833   arg4 = *argp4;
58834   {
58835     try {
58836       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (...) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58848       };
58849     }
58850   }
58851   jresult = new Dali::Animation((const Dali::Animation &)result);
58852
58853   //argout typemap for const std::string&
58854
58855   return jresult;
58856 }
58857
58858
58859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58860   void * jresult ;
58861   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58862   std::string *arg2 = 0 ;
58863   Dali::BaseHandle result;
58864
58865   arg1 = (Dali::Toolkit::Builder *)jarg1;
58866   if (!jarg2) {
58867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58868     return 0;
58869   }
58870   std::string arg2_str(jarg2);
58871   arg2 = &arg2_str;
58872   {
58873     try {
58874       result = (arg1)->Create((std::string const &)*arg2);
58875     } catch (std::out_of_range& e) {
58876       {
58877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58878       };
58879     } catch (std::exception& e) {
58880       {
58881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58886       };
58887     }
58888   }
58889   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58890
58891   //argout typemap for const std::string&
58892
58893   return jresult;
58894 }
58895
58896
58897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58898   void * jresult ;
58899   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58900   std::string *arg2 = 0 ;
58901   Dali::Property::Map *arg3 = 0 ;
58902   Dali::BaseHandle result;
58903
58904   arg1 = (Dali::Toolkit::Builder *)jarg1;
58905   if (!jarg2) {
58906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58907     return 0;
58908   }
58909   std::string arg2_str(jarg2);
58910   arg2 = &arg2_str;
58911   arg3 = (Dali::Property::Map *)jarg3;
58912   if (!arg3) {
58913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58914     return 0;
58915   }
58916   {
58917     try {
58918       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (...) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58930       };
58931     }
58932   }
58933   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58934
58935   //argout typemap for const std::string&
58936
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58942   void * jresult ;
58943   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58944   std::string *arg2 = 0 ;
58945   Dali::BaseHandle result;
58946
58947   arg1 = (Dali::Toolkit::Builder *)jarg1;
58948   if (!jarg2) {
58949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58950     return 0;
58951   }
58952   std::string arg2_str(jarg2);
58953   arg2 = &arg2_str;
58954   {
58955     try {
58956       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58957     } catch (std::out_of_range& e) {
58958       {
58959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (std::exception& e) {
58962       {
58963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58972
58973   //argout typemap for const std::string&
58974
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58980   unsigned int jresult ;
58981   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58982   std::string *arg2 = 0 ;
58983   Dali::Handle *arg3 = 0 ;
58984   bool result;
58985
58986   arg1 = (Dali::Toolkit::Builder *)jarg1;
58987   if (!jarg2) {
58988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58989     return 0;
58990   }
58991   std::string arg2_str(jarg2);
58992   arg2 = &arg2_str;
58993   arg3 = (Dali::Handle *)jarg3;
58994   if (!arg3) {
58995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58996     return 0;
58997   }
58998   {
58999     try {
59000       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
59001     } catch (std::out_of_range& e) {
59002       {
59003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59004       };
59005     } catch (std::exception& e) {
59006       {
59007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (...) {
59010       {
59011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59012       };
59013     }
59014   }
59015   jresult = result;
59016
59017   //argout typemap for const std::string&
59018
59019   return jresult;
59020 }
59021
59022
59023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59024   unsigned int jresult ;
59025   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59026   Dali::Handle *arg2 = 0 ;
59027   std::string *arg3 = 0 ;
59028   bool result;
59029
59030   arg1 = (Dali::Toolkit::Builder *)jarg1;
59031   arg2 = (Dali::Handle *)jarg2;
59032   if (!arg2) {
59033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59034     return 0;
59035   }
59036   if (!jarg3) {
59037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59038     return 0;
59039   }
59040   std::string arg3_str(jarg3);
59041   arg3 = &arg3_str;
59042   {
59043     try {
59044       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59045     } catch (std::out_of_range& e) {
59046       {
59047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (std::exception& e) {
59050       {
59051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (...) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59056       };
59057     }
59058   }
59059   jresult = result;
59060
59061   //argout typemap for const std::string&
59062
59063   return jresult;
59064 }
59065
59066
59067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59068   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59069   Dali::Actor arg2 ;
59070   Dali::Actor *argp2 ;
59071
59072   arg1 = (Dali::Toolkit::Builder *)jarg1;
59073   argp2 = (Dali::Actor *)jarg2;
59074   if (!argp2) {
59075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59076     return ;
59077   }
59078   arg2 = *argp2;
59079   {
59080     try {
59081       (arg1)->AddActors(arg2);
59082     } catch (std::out_of_range& e) {
59083       {
59084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (std::exception& e) {
59087       {
59088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096 }
59097
59098
59099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59101   std::string *arg2 = 0 ;
59102   Dali::Actor arg3 ;
59103   Dali::Actor *argp3 ;
59104
59105   arg1 = (Dali::Toolkit::Builder *)jarg1;
59106   if (!jarg2) {
59107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59108     return ;
59109   }
59110   std::string arg2_str(jarg2);
59111   arg2 = &arg2_str;
59112   argp3 = (Dali::Actor *)jarg3;
59113   if (!argp3) {
59114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59115     return ;
59116   }
59117   arg3 = *argp3;
59118   {
59119     try {
59120       (arg1)->AddActors((std::string const &)*arg2,arg3);
59121     } catch (std::out_of_range& e) {
59122       {
59123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59124       };
59125     } catch (std::exception& e) {
59126       {
59127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59128       };
59129     } catch (...) {
59130       {
59131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59132       };
59133     }
59134   }
59135
59136   //argout typemap for const std::string&
59137
59138 }
59139
59140
59141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59142   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59143   std::string *arg2 = 0 ;
59144
59145   arg1 = (Dali::Toolkit::Builder *)jarg1;
59146   if (!jarg2) {
59147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59148     return ;
59149   }
59150   std::string arg2_str(jarg2);
59151   arg2 = &arg2_str;
59152   {
59153     try {
59154       (arg1)->CreateRenderTask((std::string const &)*arg2);
59155     } catch (std::out_of_range& e) {
59156       {
59157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59158       };
59159     } catch (std::exception& e) {
59160       {
59161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59162       };
59163     } catch (...) {
59164       {
59165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59166       };
59167     }
59168   }
59169
59170   //argout typemap for const std::string&
59171
59172 }
59173
59174
59175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59176   void * jresult ;
59177   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59178   std::string *arg2 = 0 ;
59179   Dali::FrameBufferImage result;
59180
59181   arg1 = (Dali::Toolkit::Builder *)jarg1;
59182   if (!jarg2) {
59183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59184     return 0;
59185   }
59186   std::string arg2_str(jarg2);
59187   arg2 = &arg2_str;
59188   {
59189     try {
59190       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59191     } catch (std::out_of_range& e) {
59192       {
59193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59194       };
59195     } catch (std::exception& e) {
59196       {
59197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59202       };
59203     }
59204   }
59205   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59206
59207   //argout typemap for const std::string&
59208
59209   return jresult;
59210 }
59211
59212
59213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59214   void * jresult ;
59215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59216   std::string *arg2 = 0 ;
59217   Dali::Path result;
59218
59219   arg1 = (Dali::Toolkit::Builder *)jarg1;
59220   if (!jarg2) {
59221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59222     return 0;
59223   }
59224   std::string arg2_str(jarg2);
59225   arg2 = &arg2_str;
59226   {
59227     try {
59228       result = (arg1)->GetPath((std::string const &)*arg2);
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59240       };
59241     }
59242   }
59243   jresult = new Dali::Path((const Dali::Path &)result);
59244
59245   //argout typemap for const std::string&
59246
59247   return jresult;
59248 }
59249
59250
59251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59252   void * jresult ;
59253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59254   std::string *arg2 = 0 ;
59255   Dali::PathConstrainer result;
59256
59257   arg1 = (Dali::Toolkit::Builder *)jarg1;
59258   if (!jarg2) {
59259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59260     return 0;
59261   }
59262   std::string arg2_str(jarg2);
59263   arg2 = &arg2_str;
59264   {
59265     try {
59266       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (...) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59278       };
59279     }
59280   }
59281   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59282
59283   //argout typemap for const std::string&
59284
59285   return jresult;
59286 }
59287
59288
59289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59290   void * jresult ;
59291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59292   std::string *arg2 = 0 ;
59293   Dali::LinearConstrainer result;
59294
59295   arg1 = (Dali::Toolkit::Builder *)jarg1;
59296   if (!jarg2) {
59297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59298     return 0;
59299   }
59300   std::string arg2_str(jarg2);
59301   arg2 = &arg2_str;
59302   {
59303     try {
59304       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59305     } catch (std::out_of_range& e) {
59306       {
59307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59308       };
59309     } catch (std::exception& e) {
59310       {
59311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (...) {
59314       {
59315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59316       };
59317     }
59318   }
59319   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59320
59321   //argout typemap for const std::string&
59322
59323   return jresult;
59324 }
59325
59326
59327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59328   void * jresult ;
59329   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59330   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59331
59332   arg1 = (Dali::Toolkit::Builder *)jarg1;
59333   {
59334     try {
59335       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59336     } catch (std::out_of_range& e) {
59337       {
59338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (std::exception& e) {
59341       {
59342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (...) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59347       };
59348     }
59349   }
59350   jresult = (void *)result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59356   void * jresult ;
59357   Dali::Toolkit::TransitionData *result = 0 ;
59358
59359   {
59360     try {
59361       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (...) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59373       };
59374     }
59375   }
59376   jresult = (void *)result;
59377   return jresult;
59378 }
59379
59380
59381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59382   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59383
59384   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59385   {
59386     try {
59387       delete arg1;
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (...) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59399       };
59400     }
59401   }
59402 }
59403
59404
59405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59406   void * jresult ;
59407   Dali::Property::Map *arg1 = 0 ;
59408   Dali::Toolkit::TransitionData result;
59409
59410   arg1 = (Dali::Property::Map *)jarg1;
59411   if (!arg1) {
59412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59413     return 0;
59414   }
59415   {
59416     try {
59417       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59418     } catch (std::out_of_range& e) {
59419       {
59420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (std::exception& e) {
59423       {
59424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59433   return jresult;
59434 }
59435
59436
59437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59438   void * jresult ;
59439   Dali::Property::Array *arg1 = 0 ;
59440   Dali::Toolkit::TransitionData result;
59441
59442   arg1 = (Dali::Property::Array *)jarg1;
59443   if (!arg1) {
59444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59445     return 0;
59446   }
59447   {
59448     try {
59449       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59450     } catch (std::out_of_range& e) {
59451       {
59452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59453       };
59454     } catch (std::exception& e) {
59455       {
59456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59457       };
59458     } catch (...) {
59459       {
59460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59461       };
59462     }
59463   }
59464   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59470   void * jresult ;
59471   Dali::BaseHandle arg1 ;
59472   Dali::BaseHandle *argp1 ;
59473   Dali::Toolkit::TransitionData result;
59474
59475   argp1 = (Dali::BaseHandle *)jarg1;
59476   if (!argp1) {
59477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59478     return 0;
59479   }
59480   arg1 = *argp1;
59481   {
59482     try {
59483       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59484     } catch (std::out_of_range& e) {
59485       {
59486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59487       };
59488     } catch (std::exception& e) {
59489       {
59490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (...) {
59493       {
59494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59495       };
59496     }
59497   }
59498   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59504   void * jresult ;
59505   Dali::Toolkit::TransitionData *arg1 = 0 ;
59506   Dali::Toolkit::TransitionData *result = 0 ;
59507
59508   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59509   if (!arg1) {
59510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59511     return 0;
59512   }
59513   {
59514     try {
59515       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59516     } catch (std::out_of_range& e) {
59517       {
59518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59519       };
59520     } catch (std::exception& e) {
59521       {
59522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (...) {
59525       {
59526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59527       };
59528     }
59529   }
59530   jresult = (void *)result;
59531   return jresult;
59532 }
59533
59534
59535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59536   void * jresult ;
59537   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59538   Dali::Toolkit::TransitionData *arg2 = 0 ;
59539   Dali::Toolkit::TransitionData *result = 0 ;
59540
59541   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59542   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59543   if (!arg2) {
59544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59545     return 0;
59546   }
59547   {
59548     try {
59549       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59550     } catch (std::out_of_range& e) {
59551       {
59552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (std::exception& e) {
59555       {
59556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564   jresult = (void *)result;
59565   return jresult;
59566 }
59567
59568
59569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59570   unsigned long jresult ;
59571   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59572   size_t result;
59573
59574   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59575   {
59576     try {
59577       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59578     } catch (std::out_of_range& e) {
59579       {
59580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59581       };
59582     } catch (std::exception& e) {
59583       {
59584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59585       };
59586     } catch (...) {
59587       {
59588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59589       };
59590     }
59591   }
59592   jresult = (unsigned long)result;
59593   return jresult;
59594 }
59595
59596
59597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59598   void * jresult ;
59599   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59600   size_t arg2 ;
59601   Dali::Property::Map result;
59602
59603   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59604   arg2 = (size_t)jarg2;
59605   {
59606     try {
59607       result = (arg1)->GetAnimatorAt(arg2);
59608     } catch (std::out_of_range& e) {
59609       {
59610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59611       };
59612     } catch (std::exception& e) {
59613       {
59614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59615       };
59616     } catch (...) {
59617       {
59618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59619       };
59620     }
59621   }
59622   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59628   void * jresult ;
59629   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59630   Dali::Toolkit::TransitionData *result = 0 ;
59631
59632   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59633   {
59634     try {
59635       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59636     } catch (std::out_of_range& e) {
59637       {
59638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59639       };
59640     } catch (std::exception& e) {
59641       {
59642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (...) {
59645       {
59646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59647       };
59648     }
59649   }
59650   jresult = (void *)result;
59651   return jresult;
59652 }
59653
59654
59655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59656   int jresult ;
59657   int result;
59658
59659   {
59660     try {
59661       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59662     } catch (std::out_of_range& e) {
59663       {
59664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59665       };
59666     } catch (std::exception& e) {
59667       {
59668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59669       };
59670     } catch (...) {
59671       {
59672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59673       };
59674     }
59675   }
59676   jresult = (int)result;
59677   return jresult;
59678 }
59679
59680
59681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59682   int jresult ;
59683   int result;
59684
59685   {
59686     try {
59687       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59688     } catch (std::out_of_range& e) {
59689       {
59690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59691       };
59692     } catch (std::exception& e) {
59693       {
59694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59695       };
59696     } catch (...) {
59697       {
59698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59699       };
59700     }
59701   }
59702   jresult = (int)result;
59703   return jresult;
59704 }
59705
59706
59707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59708   int jresult ;
59709   int result;
59710
59711   {
59712     try {
59713       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59714     } catch (std::out_of_range& e) {
59715       {
59716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59717       };
59718     } catch (std::exception& e) {
59719       {
59720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59721       };
59722     } catch (...) {
59723       {
59724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59725       };
59726     }
59727   }
59728   jresult = (int)result;
59729   return jresult;
59730 }
59731
59732
59733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59734   int jresult ;
59735   int result;
59736
59737   {
59738     try {
59739       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59740     } catch (std::out_of_range& e) {
59741       {
59742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (std::exception& e) {
59745       {
59746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (...) {
59749       {
59750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59751       };
59752     }
59753   }
59754   jresult = (int)result;
59755   return jresult;
59756 }
59757
59758
59759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59760   int jresult ;
59761   int result;
59762
59763   {
59764     try {
59765       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59766     } catch (std::out_of_range& e) {
59767       {
59768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59769       };
59770     } catch (std::exception& e) {
59771       {
59772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59773       };
59774     } catch (...) {
59775       {
59776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59777       };
59778     }
59779   }
59780   jresult = (int)result;
59781   return jresult;
59782 }
59783
59784
59785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59786   int jresult ;
59787   int result;
59788
59789   {
59790     try {
59791       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59792     } catch (std::out_of_range& e) {
59793       {
59794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59795       };
59796     } catch (std::exception& e) {
59797       {
59798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (...) {
59801       {
59802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59803       };
59804     }
59805   }
59806   jresult = (int)result;
59807   return jresult;
59808 }
59809
59810
59811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59812   int jresult ;
59813   int result;
59814
59815   {
59816     try {
59817       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59818     } catch (std::out_of_range& e) {
59819       {
59820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59821       };
59822     } catch (std::exception& e) {
59823       {
59824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59825       };
59826     } catch (...) {
59827       {
59828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59829       };
59830     }
59831   }
59832   jresult = (int)result;
59833   return jresult;
59834 }
59835
59836
59837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59838   int jresult ;
59839   int result;
59840
59841   {
59842     try {
59843       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59844     } catch (std::out_of_range& e) {
59845       {
59846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59847       };
59848     } catch (std::exception& e) {
59849       {
59850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59851       };
59852     } catch (...) {
59853       {
59854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59855       };
59856     }
59857   }
59858   jresult = (int)result;
59859   return jresult;
59860 }
59861
59862
59863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59864   int jresult ;
59865   int result;
59866
59867   {
59868     try {
59869       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59870     } catch (std::out_of_range& e) {
59871       {
59872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59873       };
59874     } catch (std::exception& e) {
59875       {
59876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59877       };
59878     } catch (...) {
59879       {
59880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59881       };
59882     }
59883   }
59884   jresult = (int)result;
59885   return jresult;
59886 }
59887
59888
59889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59890   int jresult ;
59891   int result;
59892
59893   {
59894     try {
59895       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59896     } catch (std::out_of_range& e) {
59897       {
59898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59899       };
59900     } catch (std::exception& e) {
59901       {
59902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59903       };
59904     } catch (...) {
59905       {
59906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59907       };
59908     }
59909   }
59910   jresult = (int)result;
59911   return jresult;
59912 }
59913
59914
59915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59916   int jresult ;
59917   int result;
59918
59919   {
59920     try {
59921       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59922     } catch (std::out_of_range& e) {
59923       {
59924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59925       };
59926     } catch (std::exception& e) {
59927       {
59928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (...) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59933       };
59934     }
59935   }
59936   jresult = (int)result;
59937   return jresult;
59938 }
59939
59940
59941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59942   int jresult ;
59943   int result;
59944
59945   {
59946     try {
59947       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59948     } catch (std::out_of_range& e) {
59949       {
59950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59951       };
59952     } catch (std::exception& e) {
59953       {
59954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (...) {
59957       {
59958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59959       };
59960     }
59961   }
59962   jresult = (int)result;
59963   return jresult;
59964 }
59965
59966
59967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59968   int jresult ;
59969   int result;
59970
59971   {
59972     try {
59973       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59974     } catch (std::out_of_range& e) {
59975       {
59976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59977       };
59978     } catch (std::exception& e) {
59979       {
59980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (...) {
59983       {
59984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59985       };
59986     }
59987   }
59988   jresult = (int)result;
59989   return jresult;
59990 }
59991
59992
59993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59994   int jresult ;
59995   int result;
59996
59997   {
59998     try {
59999       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
60000     } catch (std::out_of_range& e) {
60001       {
60002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60003       };
60004     } catch (std::exception& e) {
60005       {
60006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (...) {
60009       {
60010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60011       };
60012     }
60013   }
60014   jresult = (int)result;
60015   return jresult;
60016 }
60017
60018
60019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
60020   void * jresult ;
60021   Dali::Toolkit::Control result;
60022
60023   {
60024     try {
60025       result = Dali::Toolkit::Internal::Control::New();
60026     } catch (std::out_of_range& e) {
60027       {
60028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (std::exception& e) {
60031       {
60032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60041   return jresult;
60042 }
60043
60044
60045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60047   std::string *arg2 = 0 ;
60048
60049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60050   if (!jarg2) {
60051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60052     return ;
60053   }
60054   std::string arg2_str(jarg2);
60055   arg2 = &arg2_str;
60056   {
60057     try {
60058       (arg1)->SetStyleName((std::string const &)*arg2);
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60070       };
60071     }
60072   }
60073
60074   //argout typemap for const std::string&
60075
60076 }
60077
60078
60079 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60080   char * jresult ;
60081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60082   std::string *result = 0 ;
60083
60084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60085   {
60086     try {
60087       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60088     } catch (std::out_of_range& e) {
60089       {
60090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (std::exception& e) {
60093       {
60094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102   jresult = SWIG_csharp_string_callback(result->c_str());
60103   return jresult;
60104 }
60105
60106
60107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60109   Dali::Vector4 *arg2 = 0 ;
60110
60111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60112   arg2 = (Dali::Vector4 *)jarg2;
60113   if (!arg2) {
60114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60115     return ;
60116   }
60117   {
60118     try {
60119       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60120     } catch (std::out_of_range& e) {
60121       {
60122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60123       };
60124     } catch (std::exception& e) {
60125       {
60126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60127       };
60128     } catch (...) {
60129       {
60130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60131       };
60132     }
60133   }
60134 }
60135
60136
60137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60138   void * jresult ;
60139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60140   Dali::Vector4 result;
60141
60142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60143   {
60144     try {
60145       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60146     } catch (std::out_of_range& e) {
60147       {
60148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60149       };
60150     } catch (std::exception& e) {
60151       {
60152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60153       };
60154     } catch (...) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60157       };
60158     }
60159   }
60160   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60161   return jresult;
60162 }
60163
60164
60165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60167   Dali::Image arg2 ;
60168   Dali::Image *argp2 ;
60169
60170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60171   argp2 = (Dali::Image *)jarg2;
60172   if (!argp2) {
60173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60174     return ;
60175   }
60176   arg2 = *argp2;
60177   {
60178     try {
60179       (arg1)->SetBackgroundImage(arg2);
60180     } catch (std::out_of_range& e) {
60181       {
60182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60183       };
60184     } catch (std::exception& e) {
60185       {
60186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60187       };
60188     } catch (...) {
60189       {
60190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60191       };
60192     }
60193   }
60194 }
60195
60196
60197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60198   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60199   Dali::Property::Map *arg2 = 0 ;
60200
60201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60202   arg2 = (Dali::Property::Map *)jarg2;
60203   if (!arg2) {
60204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60205     return ;
60206   }
60207   {
60208     try {
60209       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60210     } catch (std::out_of_range& e) {
60211       {
60212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60213       };
60214     } catch (std::exception& e) {
60215       {
60216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60217       };
60218     } catch (...) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60221       };
60222     }
60223   }
60224 }
60225
60226
60227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60229
60230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60231   {
60232     try {
60233       (arg1)->ClearBackground();
60234     } catch (std::out_of_range& e) {
60235       {
60236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60237       };
60238     } catch (std::exception& e) {
60239       {
60240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60241       };
60242     } catch (...) {
60243       {
60244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60245       };
60246     }
60247   }
60248 }
60249
60250
60251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60253   Dali::Gesture::Type arg2 ;
60254
60255   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60256   arg2 = (Dali::Gesture::Type)jarg2;
60257   {
60258     try {
60259       (arg1)->EnableGestureDetection(arg2);
60260     } catch (std::out_of_range& e) {
60261       {
60262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60263       };
60264     } catch (std::exception& e) {
60265       {
60266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60267       };
60268     } catch (...) {
60269       {
60270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60271       };
60272     }
60273   }
60274 }
60275
60276
60277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60279   Dali::Gesture::Type arg2 ;
60280
60281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60282   arg2 = (Dali::Gesture::Type)jarg2;
60283   {
60284     try {
60285       (arg1)->DisableGestureDetection(arg2);
60286     } catch (std::out_of_range& e) {
60287       {
60288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60289       };
60290     } catch (std::exception& e) {
60291       {
60292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60293       };
60294     } catch (...) {
60295       {
60296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60297       };
60298     }
60299   }
60300 }
60301
60302
60303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60304   void * jresult ;
60305   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60306   Dali::PinchGestureDetector result;
60307
60308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60309   {
60310     try {
60311       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60312     } catch (std::out_of_range& e) {
60313       {
60314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60315       };
60316     } catch (std::exception& e) {
60317       {
60318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60319       };
60320     } catch (...) {
60321       {
60322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60323       };
60324     }
60325   }
60326   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60327   return jresult;
60328 }
60329
60330
60331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60332   void * jresult ;
60333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60334   Dali::PanGestureDetector result;
60335
60336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60337   {
60338     try {
60339       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60340     } catch (std::out_of_range& e) {
60341       {
60342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60343       };
60344     } catch (std::exception& e) {
60345       {
60346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60347       };
60348     } catch (...) {
60349       {
60350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60351       };
60352     }
60353   }
60354   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60355   return jresult;
60356 }
60357
60358
60359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60360   void * jresult ;
60361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60362   Dali::TapGestureDetector result;
60363
60364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60365   {
60366     try {
60367       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60368     } catch (std::out_of_range& e) {
60369       {
60370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60371       };
60372     } catch (std::exception& e) {
60373       {
60374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60375       };
60376     } catch (...) {
60377       {
60378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60379       };
60380     }
60381   }
60382   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60383   return jresult;
60384 }
60385
60386
60387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60388   void * jresult ;
60389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60390   Dali::LongPressGestureDetector result;
60391
60392   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60393   {
60394     try {
60395       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (...) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60407       };
60408     }
60409   }
60410   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60411   return jresult;
60412 }
60413
60414
60415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60417   bool arg2 ;
60418
60419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60420   arg2 = jarg2 ? true : false;
60421   {
60422     try {
60423       (arg1)->SetKeyboardNavigationSupport(arg2);
60424     } catch (std::out_of_range& e) {
60425       {
60426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60427       };
60428     } catch (std::exception& e) {
60429       {
60430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60431       };
60432     } catch (...) {
60433       {
60434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60435       };
60436     }
60437   }
60438 }
60439
60440
60441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60442   unsigned int jresult ;
60443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60444   bool result;
60445
60446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60447   {
60448     try {
60449       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60450     } catch (std::out_of_range& e) {
60451       {
60452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60453       };
60454     } catch (std::exception& e) {
60455       {
60456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60457       };
60458     } catch (...) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60461       };
60462     }
60463   }
60464   jresult = result;
60465   return jresult;
60466 }
60467
60468
60469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60471
60472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60473   {
60474     try {
60475       (arg1)->SetKeyInputFocus();
60476     } catch (std::out_of_range& e) {
60477       {
60478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60479       };
60480     } catch (std::exception& e) {
60481       {
60482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60487       };
60488     }
60489   }
60490 }
60491
60492
60493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60494   unsigned int jresult ;
60495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60496   bool result;
60497
60498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60499   {
60500     try {
60501       result = (bool)(arg1)->HasKeyInputFocus();
60502     } catch (std::out_of_range& e) {
60503       {
60504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60505       };
60506     } catch (std::exception& e) {
60507       {
60508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60509       };
60510     } catch (...) {
60511       {
60512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60513       };
60514     }
60515   }
60516   jresult = result;
60517   return jresult;
60518 }
60519
60520
60521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60523
60524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60525   {
60526     try {
60527       (arg1)->ClearKeyInputFocus();
60528     } catch (std::out_of_range& e) {
60529       {
60530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60531       };
60532     } catch (std::exception& e) {
60533       {
60534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60535       };
60536     } catch (...) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60539       };
60540     }
60541   }
60542 }
60543
60544
60545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60547   bool arg2 ;
60548
60549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60550   arg2 = jarg2 ? true : false;
60551   {
60552     try {
60553       (arg1)->SetAsKeyboardFocusGroup(arg2);
60554     } catch (std::out_of_range& e) {
60555       {
60556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60557       };
60558     } catch (std::exception& e) {
60559       {
60560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60565       };
60566     }
60567   }
60568 }
60569
60570
60571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60572   unsigned int jresult ;
60573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60574   bool result;
60575
60576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60577   {
60578     try {
60579       result = (bool)(arg1)->IsKeyboardFocusGroup();
60580     } catch (std::out_of_range& e) {
60581       {
60582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (std::exception& e) {
60585       {
60586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594   jresult = result;
60595   return jresult;
60596 }
60597
60598
60599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60601
60602   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60603   {
60604     try {
60605       (arg1)->AccessibilityActivate();
60606     } catch (std::out_of_range& e) {
60607       {
60608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60609       };
60610     } catch (std::exception& e) {
60611       {
60612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60613       };
60614     } catch (...) {
60615       {
60616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60617       };
60618     }
60619   }
60620 }
60621
60622
60623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60625
60626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60627   {
60628     try {
60629       (arg1)->KeyboardEnter();
60630     } catch (std::out_of_range& e) {
60631       {
60632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60633       };
60634     } catch (std::exception& e) {
60635       {
60636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60637       };
60638     } catch (...) {
60639       {
60640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60641       };
60642     }
60643   }
60644 }
60645
60646
60647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60648   void * jresult ;
60649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60650   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60651
60652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60653   {
60654     try {
60655       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60656     } catch (std::out_of_range& e) {
60657       {
60658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (std::exception& e) {
60661       {
60662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60667       };
60668     }
60669   }
60670   jresult = (void *)result;
60671   return jresult;
60672 }
60673
60674
60675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60676   void * jresult ;
60677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60678   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60679
60680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60681   {
60682     try {
60683       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60684     } catch (std::out_of_range& e) {
60685       {
60686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60687       };
60688     } catch (std::exception& e) {
60689       {
60690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60691       };
60692     } catch (...) {
60693       {
60694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60695       };
60696     }
60697   }
60698   jresult = (void *)result;
60699   return jresult;
60700 }
60701
60702
60703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60704   void * jresult ;
60705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60706   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60707
60708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60709   {
60710     try {
60711       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60712     } catch (std::out_of_range& e) {
60713       {
60714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (std::exception& e) {
60717       {
60718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (...) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60723       };
60724     }
60725   }
60726   jresult = (void *)result;
60727   return jresult;
60728 }
60729
60730
60731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60732   unsigned int jresult ;
60733   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60734   Dali::KeyEvent *arg2 = 0 ;
60735   bool result;
60736
60737   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60738   arg2 = (Dali::KeyEvent *)jarg2;
60739   if (!arg2) {
60740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60741     return 0;
60742   }
60743   {
60744     try {
60745       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60746     } catch (std::out_of_range& e) {
60747       {
60748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (std::exception& e) {
60751       {
60752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60753       };
60754     } catch (...) {
60755       {
60756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60757       };
60758     }
60759   }
60760   jresult = result;
60761   return jresult;
60762 }
60763
60764
60765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60767   int arg2 ;
60768   SwigDirector_ViewImpl *darg = 0;
60769
60770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60771   arg2 = (int)jarg2;
60772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60773   {
60774     try {
60775       (darg)->OnStageConnection(arg2);
60776     } catch (std::out_of_range& e) {
60777       {
60778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60779       };
60780     } catch (std::exception& e) {
60781       {
60782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60783       };
60784     } catch (...) {
60785       {
60786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60787       };
60788     }
60789   }
60790 }
60791
60792
60793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60795   int arg2 ;
60796   SwigDirector_ViewImpl *darg = 0;
60797
60798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60799   arg2 = (int)jarg2;
60800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60801   {
60802     try {
60803       (darg)->OnStageConnectionSwigPublic(arg2);
60804     } catch (std::out_of_range& e) {
60805       {
60806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60807       };
60808     } catch (std::exception& e) {
60809       {
60810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (...) {
60813       {
60814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60815       };
60816     }
60817   }
60818 }
60819
60820
60821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60823   SwigDirector_ViewImpl *darg = 0;
60824
60825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60827   {
60828     try {
60829       (darg)->OnStageDisconnection();
60830     } catch (std::out_of_range& e) {
60831       {
60832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60833       };
60834     } catch (std::exception& e) {
60835       {
60836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60837       };
60838     } catch (...) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60841       };
60842     }
60843   }
60844 }
60845
60846
60847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60849   SwigDirector_ViewImpl *darg = 0;
60850
60851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60853   {
60854     try {
60855       (darg)->OnStageDisconnectionSwigPublic();
60856     } catch (std::out_of_range& e) {
60857       {
60858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60859       };
60860     } catch (std::exception& e) {
60861       {
60862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60867       };
60868     }
60869   }
60870 }
60871
60872
60873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60875   Dali::Actor *arg2 = 0 ;
60876   SwigDirector_ViewImpl *darg = 0;
60877
60878   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60879   arg2 = (Dali::Actor *)jarg2;
60880   if (!arg2) {
60881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60882     return ;
60883   }
60884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60885   {
60886     try {
60887       (darg)->OnChildAdd(*arg2);
60888     } catch (std::out_of_range& e) {
60889       {
60890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60891       };
60892     } catch (std::exception& e) {
60893       {
60894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60899       };
60900     }
60901   }
60902 }
60903
60904
60905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60907   Dali::Actor *arg2 = 0 ;
60908   SwigDirector_ViewImpl *darg = 0;
60909
60910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60911   arg2 = (Dali::Actor *)jarg2;
60912   if (!arg2) {
60913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60914     return ;
60915   }
60916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60917   {
60918     try {
60919       (darg)->OnChildAddSwigPublic(*arg2);
60920     } catch (std::out_of_range& e) {
60921       {
60922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60923       };
60924     } catch (std::exception& e) {
60925       {
60926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60931       };
60932     }
60933   }
60934 }
60935
60936
60937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60939   Dali::Actor *arg2 = 0 ;
60940   SwigDirector_ViewImpl *darg = 0;
60941
60942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60943   arg2 = (Dali::Actor *)jarg2;
60944   if (!arg2) {
60945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60946     return ;
60947   }
60948   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60949   {
60950     try {
60951       (darg)->OnChildRemove(*arg2);
60952     } catch (std::out_of_range& e) {
60953       {
60954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60955       };
60956     } catch (std::exception& e) {
60957       {
60958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60963       };
60964     }
60965   }
60966 }
60967
60968
60969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60971   Dali::Actor *arg2 = 0 ;
60972   SwigDirector_ViewImpl *darg = 0;
60973
60974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60975   arg2 = (Dali::Actor *)jarg2;
60976   if (!arg2) {
60977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60978     return ;
60979   }
60980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60981   {
60982     try {
60983       (darg)->OnChildRemoveSwigPublic(*arg2);
60984     } catch (std::out_of_range& e) {
60985       {
60986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60987       };
60988     } catch (std::exception& e) {
60989       {
60990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60991       };
60992     } catch (...) {
60993       {
60994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60995       };
60996     }
60997   }
60998 }
60999
61000
61001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
61002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61003   Dali::Property::Index arg2 ;
61004   Dali::Property::Value arg3 ;
61005   Dali::Property::Value *argp3 ;
61006   SwigDirector_ViewImpl *darg = 0;
61007
61008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61009   arg2 = (Dali::Property::Index)jarg2;
61010   argp3 = (Dali::Property::Value *)jarg3;
61011   if (!argp3) {
61012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61013     return ;
61014   }
61015   arg3 = *argp3;
61016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61017   {
61018     try {
61019       (darg)->OnPropertySet(arg2,arg3);
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61027       };
61028     } catch (...) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61031       };
61032     }
61033   }
61034 }
61035
61036
61037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61039   Dali::Property::Index arg2 ;
61040   Dali::Property::Value arg3 ;
61041   Dali::Property::Value *argp3 ;
61042   SwigDirector_ViewImpl *darg = 0;
61043
61044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61045   arg2 = (Dali::Property::Index)jarg2;
61046   argp3 = (Dali::Property::Value *)jarg3;
61047   if (!argp3) {
61048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61049     return ;
61050   }
61051   arg3 = *argp3;
61052   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61053   {
61054     try {
61055       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61056     } catch (std::out_of_range& e) {
61057       {
61058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61059       };
61060     } catch (std::exception& e) {
61061       {
61062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61063       };
61064     } catch (...) {
61065       {
61066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61067       };
61068     }
61069   }
61070 }
61071
61072
61073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61075   Dali::Vector3 *arg2 = 0 ;
61076   SwigDirector_ViewImpl *darg = 0;
61077
61078   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61079   arg2 = (Dali::Vector3 *)jarg2;
61080   if (!arg2) {
61081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61082     return ;
61083   }
61084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61085   {
61086     try {
61087       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61088     } catch (std::out_of_range& e) {
61089       {
61090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61091       };
61092     } catch (std::exception& e) {
61093       {
61094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61095       };
61096     } catch (...) {
61097       {
61098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61099       };
61100     }
61101   }
61102 }
61103
61104
61105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61107   Dali::Vector3 *arg2 = 0 ;
61108   SwigDirector_ViewImpl *darg = 0;
61109
61110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61111   arg2 = (Dali::Vector3 *)jarg2;
61112   if (!arg2) {
61113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61114     return ;
61115   }
61116   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61117   {
61118     try {
61119       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61120     } catch (std::out_of_range& e) {
61121       {
61122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61123       };
61124     } catch (std::exception& e) {
61125       {
61126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61127       };
61128     } catch (...) {
61129       {
61130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61131       };
61132     }
61133   }
61134 }
61135
61136
61137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61138   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61139   Dali::Animation *arg2 = 0 ;
61140   Dali::Vector3 *arg3 = 0 ;
61141   SwigDirector_ViewImpl *darg = 0;
61142
61143   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61144   arg2 = (Dali::Animation *)jarg2;
61145   if (!arg2) {
61146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61147     return ;
61148   }
61149   arg3 = (Dali::Vector3 *)jarg3;
61150   if (!arg3) {
61151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61152     return ;
61153   }
61154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61155   {
61156     try {
61157       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61158     } catch (std::out_of_range& e) {
61159       {
61160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61161       };
61162     } catch (std::exception& e) {
61163       {
61164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61165       };
61166     } catch (...) {
61167       {
61168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61169       };
61170     }
61171   }
61172 }
61173
61174
61175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61177   Dali::Animation *arg2 = 0 ;
61178   Dali::Vector3 *arg3 = 0 ;
61179   SwigDirector_ViewImpl *darg = 0;
61180
61181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61182   arg2 = (Dali::Animation *)jarg2;
61183   if (!arg2) {
61184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61185     return ;
61186   }
61187   arg3 = (Dali::Vector3 *)jarg3;
61188   if (!arg3) {
61189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61190     return ;
61191   }
61192   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61193   {
61194     try {
61195       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61203       };
61204     } catch (...) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61207       };
61208     }
61209   }
61210 }
61211
61212
61213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61214   unsigned int jresult ;
61215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61216   Dali::TouchEvent *arg2 = 0 ;
61217   SwigDirector_ViewImpl *darg = 0;
61218   bool result;
61219
61220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61221   arg2 = (Dali::TouchEvent *)jarg2;
61222   if (!arg2) {
61223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61224     return 0;
61225   }
61226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61227   {
61228     try {
61229       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61230     } catch (std::out_of_range& e) {
61231       {
61232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61233       };
61234     } catch (std::exception& e) {
61235       {
61236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61241       };
61242     }
61243   }
61244   jresult = result;
61245   return jresult;
61246 }
61247
61248
61249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61250   unsigned int jresult ;
61251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61252   Dali::TouchEvent *arg2 = 0 ;
61253   SwigDirector_ViewImpl *darg = 0;
61254   bool result;
61255
61256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61257   arg2 = (Dali::TouchEvent *)jarg2;
61258   if (!arg2) {
61259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61260     return 0;
61261   }
61262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61263   {
61264     try {
61265       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61266     } catch (std::out_of_range& e) {
61267       {
61268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61269       };
61270     } catch (std::exception& e) {
61271       {
61272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61273       };
61274     } catch (...) {
61275       {
61276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61277       };
61278     }
61279   }
61280   jresult = result;
61281   return jresult;
61282 }
61283
61284
61285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61286   unsigned int jresult ;
61287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61288   Dali::HoverEvent *arg2 = 0 ;
61289   SwigDirector_ViewImpl *darg = 0;
61290   bool result;
61291
61292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61293   arg2 = (Dali::HoverEvent *)jarg2;
61294   if (!arg2) {
61295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61296     return 0;
61297   }
61298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61299   {
61300     try {
61301       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61309       };
61310     } catch (...) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61313       };
61314     }
61315   }
61316   jresult = result;
61317   return jresult;
61318 }
61319
61320
61321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61322   unsigned int jresult ;
61323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61324   Dali::HoverEvent *arg2 = 0 ;
61325   SwigDirector_ViewImpl *darg = 0;
61326   bool result;
61327
61328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61329   arg2 = (Dali::HoverEvent *)jarg2;
61330   if (!arg2) {
61331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61332     return 0;
61333   }
61334   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61335   {
61336     try {
61337       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61345       };
61346     } catch (...) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61349       };
61350     }
61351   }
61352   jresult = result;
61353   return jresult;
61354 }
61355
61356
61357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61358   unsigned int jresult ;
61359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61360   Dali::KeyEvent *arg2 = 0 ;
61361   SwigDirector_ViewImpl *darg = 0;
61362   bool result;
61363
61364   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61365   arg2 = (Dali::KeyEvent *)jarg2;
61366   if (!arg2) {
61367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61368     return 0;
61369   }
61370   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61371   {
61372     try {
61373       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61374     } catch (std::out_of_range& e) {
61375       {
61376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61377       };
61378     } catch (std::exception& e) {
61379       {
61380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61381       };
61382     } catch (...) {
61383       {
61384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61385       };
61386     }
61387   }
61388   jresult = result;
61389   return jresult;
61390 }
61391
61392
61393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61394   unsigned int jresult ;
61395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61396   Dali::KeyEvent *arg2 = 0 ;
61397   SwigDirector_ViewImpl *darg = 0;
61398   bool result;
61399
61400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61401   arg2 = (Dali::KeyEvent *)jarg2;
61402   if (!arg2) {
61403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61404     return 0;
61405   }
61406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61407   {
61408     try {
61409       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61410     } catch (std::out_of_range& e) {
61411       {
61412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (std::exception& e) {
61415       {
61416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (...) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61421       };
61422     }
61423   }
61424   jresult = result;
61425   return jresult;
61426 }
61427
61428
61429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61430   unsigned int jresult ;
61431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61432   Dali::WheelEvent *arg2 = 0 ;
61433   SwigDirector_ViewImpl *darg = 0;
61434   bool result;
61435
61436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61437   arg2 = (Dali::WheelEvent *)jarg2;
61438   if (!arg2) {
61439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61440     return 0;
61441   }
61442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61443   {
61444     try {
61445       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61446     } catch (std::out_of_range& e) {
61447       {
61448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (std::exception& e) {
61451       {
61452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61457       };
61458     }
61459   }
61460   jresult = result;
61461   return jresult;
61462 }
61463
61464
61465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61466   unsigned int jresult ;
61467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61468   Dali::WheelEvent *arg2 = 0 ;
61469   SwigDirector_ViewImpl *darg = 0;
61470   bool result;
61471
61472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61473   arg2 = (Dali::WheelEvent *)jarg2;
61474   if (!arg2) {
61475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61476     return 0;
61477   }
61478   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61479   {
61480     try {
61481       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61482     } catch (std::out_of_range& e) {
61483       {
61484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61485       };
61486     } catch (std::exception& e) {
61487       {
61488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61489       };
61490     } catch (...) {
61491       {
61492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61493       };
61494     }
61495   }
61496   jresult = result;
61497   return jresult;
61498 }
61499
61500
61501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61503   Dali::Vector2 *arg2 = 0 ;
61504   Dali::RelayoutContainer *arg3 = 0 ;
61505   SwigDirector_ViewImpl *darg = 0;
61506
61507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61508   arg2 = (Dali::Vector2 *)jarg2;
61509   if (!arg2) {
61510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61511     return ;
61512   }
61513   arg3 = (Dali::RelayoutContainer *)jarg3;
61514   if (!arg3) {
61515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61516     return ;
61517   }
61518   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61519   {
61520     try {
61521       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61522     } catch (std::out_of_range& e) {
61523       {
61524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61525       };
61526     } catch (std::exception& e) {
61527       {
61528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61529       };
61530     } catch (...) {
61531       {
61532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61533       };
61534     }
61535   }
61536 }
61537
61538
61539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61541   Dali::Vector2 *arg2 = 0 ;
61542   Dali::RelayoutContainer *arg3 = 0 ;
61543   SwigDirector_ViewImpl *darg = 0;
61544
61545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61546   arg2 = (Dali::Vector2 *)jarg2;
61547   if (!arg2) {
61548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61549     return ;
61550   }
61551   arg3 = (Dali::RelayoutContainer *)jarg3;
61552   if (!arg3) {
61553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61554     return ;
61555   }
61556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61557   {
61558     try {
61559       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61560     } catch (std::out_of_range& e) {
61561       {
61562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61563       };
61564     } catch (std::exception& e) {
61565       {
61566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61567       };
61568     } catch (...) {
61569       {
61570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61571       };
61572     }
61573   }
61574 }
61575
61576
61577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61579   Dali::ResizePolicy::Type arg2 ;
61580   Dali::Dimension::Type arg3 ;
61581   SwigDirector_ViewImpl *darg = 0;
61582
61583   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61584   arg2 = (Dali::ResizePolicy::Type)jarg2;
61585   arg3 = (Dali::Dimension::Type)jarg3;
61586   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61587   {
61588     try {
61589       (darg)->OnSetResizePolicy(arg2,arg3);
61590     } catch (std::out_of_range& e) {
61591       {
61592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61593       };
61594     } catch (std::exception& e) {
61595       {
61596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61597       };
61598     } catch (...) {
61599       {
61600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61601       };
61602     }
61603   }
61604 }
61605
61606
61607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61609   Dali::ResizePolicy::Type arg2 ;
61610   Dali::Dimension::Type arg3 ;
61611   SwigDirector_ViewImpl *darg = 0;
61612
61613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61614   arg2 = (Dali::ResizePolicy::Type)jarg2;
61615   arg3 = (Dali::Dimension::Type)jarg3;
61616   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61617   {
61618     try {
61619       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61620     } catch (std::out_of_range& e) {
61621       {
61622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61623       };
61624     } catch (std::exception& e) {
61625       {
61626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61627       };
61628     } catch (...) {
61629       {
61630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61631       };
61632     }
61633   }
61634 }
61635
61636
61637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61638   void * jresult ;
61639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61640   SwigDirector_ViewImpl *darg = 0;
61641   Dali::Vector3 result;
61642
61643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61645   {
61646     try {
61647       result = (darg)->GetNaturalSize();
61648     } catch (std::out_of_range& e) {
61649       {
61650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61651       };
61652     } catch (std::exception& e) {
61653       {
61654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61655       };
61656     } catch (...) {
61657       {
61658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61659       };
61660     }
61661   }
61662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61663   return jresult;
61664 }
61665
61666
61667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61668   void * jresult ;
61669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61670   SwigDirector_ViewImpl *darg = 0;
61671   Dali::Vector3 result;
61672
61673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61674   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61675   {
61676     try {
61677       result = (darg)->GetNaturalSizeSwigPublic();
61678     } catch (std::out_of_range& e) {
61679       {
61680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (std::exception& e) {
61683       {
61684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61685       };
61686     } catch (...) {
61687       {
61688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61689       };
61690     }
61691   }
61692   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61693   return jresult;
61694 }
61695
61696
61697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61698   float jresult ;
61699   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61700   Dali::Actor *arg2 = 0 ;
61701   Dali::Dimension::Type arg3 ;
61702   SwigDirector_ViewImpl *darg = 0;
61703   float result;
61704
61705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61706   arg2 = (Dali::Actor *)jarg2;
61707   if (!arg2) {
61708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61709     return 0;
61710   }
61711   arg3 = (Dali::Dimension::Type)jarg3;
61712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61713   {
61714     try {
61715       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61716     } catch (std::out_of_range& e) {
61717       {
61718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61719       };
61720     } catch (std::exception& e) {
61721       {
61722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61723       };
61724     } catch (...) {
61725       {
61726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61727       };
61728     }
61729   }
61730   jresult = result;
61731   return jresult;
61732 }
61733
61734
61735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61736   float jresult ;
61737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61738   Dali::Actor *arg2 = 0 ;
61739   Dali::Dimension::Type arg3 ;
61740   SwigDirector_ViewImpl *darg = 0;
61741   float result;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   arg2 = (Dali::Actor *)jarg2;
61745   if (!arg2) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61747     return 0;
61748   }
61749   arg3 = (Dali::Dimension::Type)jarg3;
61750   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61751   {
61752     try {
61753       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61754     } catch (std::out_of_range& e) {
61755       {
61756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (std::exception& e) {
61759       {
61760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768   jresult = result;
61769   return jresult;
61770 }
61771
61772
61773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61774   float jresult ;
61775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61776   float arg2 ;
61777   SwigDirector_ViewImpl *darg = 0;
61778   float result;
61779
61780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61781   arg2 = (float)jarg2;
61782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61783   {
61784     try {
61785       result = (float)(darg)->GetHeightForWidth(arg2);
61786     } catch (std::out_of_range& e) {
61787       {
61788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61789       };
61790     } catch (std::exception& e) {
61791       {
61792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61793       };
61794     } catch (...) {
61795       {
61796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61797       };
61798     }
61799   }
61800   jresult = result;
61801   return jresult;
61802 }
61803
61804
61805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61806   float jresult ;
61807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61808   float arg2 ;
61809   SwigDirector_ViewImpl *darg = 0;
61810   float result;
61811
61812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61813   arg2 = (float)jarg2;
61814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61815   {
61816     try {
61817       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61818     } catch (std::out_of_range& e) {
61819       {
61820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61821       };
61822     } catch (std::exception& e) {
61823       {
61824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61825       };
61826     } catch (...) {
61827       {
61828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61829       };
61830     }
61831   }
61832   jresult = result;
61833   return jresult;
61834 }
61835
61836
61837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61838   float jresult ;
61839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61840   float arg2 ;
61841   SwigDirector_ViewImpl *darg = 0;
61842   float result;
61843
61844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61845   arg2 = (float)jarg2;
61846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61847   {
61848     try {
61849       result = (float)(darg)->GetWidthForHeight(arg2);
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (...) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61861       };
61862     }
61863   }
61864   jresult = result;
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61870   float jresult ;
61871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61872   float arg2 ;
61873   SwigDirector_ViewImpl *darg = 0;
61874   float result;
61875
61876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61877   arg2 = (float)jarg2;
61878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61879   {
61880     try {
61881       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61882     } catch (std::out_of_range& e) {
61883       {
61884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61885       };
61886     } catch (std::exception& e) {
61887       {
61888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61889       };
61890     } catch (...) {
61891       {
61892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61893       };
61894     }
61895   }
61896   jresult = result;
61897   return jresult;
61898 }
61899
61900
61901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61902   unsigned int jresult ;
61903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61904   Dali::Dimension::Type arg2 ;
61905   SwigDirector_ViewImpl *darg = 0;
61906   bool result;
61907
61908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61909   arg2 = (Dali::Dimension::Type)jarg2;
61910   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61911   {
61912     try {
61913       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61914     } catch (std::out_of_range& e) {
61915       {
61916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61917       };
61918     } catch (std::exception& e) {
61919       {
61920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61921       };
61922     } catch (...) {
61923       {
61924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61925       };
61926     }
61927   }
61928   jresult = result;
61929   return jresult;
61930 }
61931
61932
61933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61934   unsigned int jresult ;
61935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61936   Dali::Dimension::Type arg2 ;
61937   SwigDirector_ViewImpl *darg = 0;
61938   bool result;
61939
61940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61941   arg2 = (Dali::Dimension::Type)jarg2;
61942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61943   {
61944     try {
61945       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61946     } catch (std::out_of_range& e) {
61947       {
61948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61949       };
61950     } catch (std::exception& e) {
61951       {
61952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61953       };
61954     } catch (...) {
61955       {
61956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61957       };
61958     }
61959   }
61960   jresult = result;
61961   return jresult;
61962 }
61963
61964
61965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61966   unsigned int jresult ;
61967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61968   SwigDirector_ViewImpl *darg = 0;
61969   bool result;
61970
61971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61972   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61973   {
61974     try {
61975       result = (bool)(darg)->RelayoutDependentOnChildren();
61976     } catch (std::out_of_range& e) {
61977       {
61978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61979       };
61980     } catch (std::exception& e) {
61981       {
61982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61983       };
61984     } catch (...) {
61985       {
61986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61987       };
61988     }
61989   }
61990   jresult = result;
61991   return jresult;
61992 }
61993
61994
61995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61996   unsigned int jresult ;
61997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61998   SwigDirector_ViewImpl *darg = 0;
61999   bool result;
62000
62001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62002   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62003   {
62004     try {
62005       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
62006     } catch (std::out_of_range& e) {
62007       {
62008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62009       };
62010     } catch (std::exception& e) {
62011       {
62012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62013       };
62014     } catch (...) {
62015       {
62016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62017       };
62018     }
62019   }
62020   jresult = result;
62021   return jresult;
62022 }
62023
62024
62025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62027   Dali::Dimension::Type arg2 ;
62028   SwigDirector_ViewImpl *darg = 0;
62029
62030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62031   arg2 = (Dali::Dimension::Type)jarg2;
62032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62033   {
62034     try {
62035       (darg)->OnCalculateRelayoutSize(arg2);
62036     } catch (std::out_of_range& e) {
62037       {
62038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62039       };
62040     } catch (std::exception& e) {
62041       {
62042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62043       };
62044     } catch (...) {
62045       {
62046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62047       };
62048     }
62049   }
62050 }
62051
62052
62053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62055   Dali::Dimension::Type arg2 ;
62056   SwigDirector_ViewImpl *darg = 0;
62057
62058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62059   arg2 = (Dali::Dimension::Type)jarg2;
62060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62061   {
62062     try {
62063       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62064     } catch (std::out_of_range& e) {
62065       {
62066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62067       };
62068     } catch (std::exception& e) {
62069       {
62070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62071       };
62072     } catch (...) {
62073       {
62074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62075       };
62076     }
62077   }
62078 }
62079
62080
62081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62083   float arg2 ;
62084   Dali::Dimension::Type arg3 ;
62085   SwigDirector_ViewImpl *darg = 0;
62086
62087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62088   arg2 = (float)jarg2;
62089   arg3 = (Dali::Dimension::Type)jarg3;
62090   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62091   {
62092     try {
62093       (darg)->OnLayoutNegotiated(arg2,arg3);
62094     } catch (std::out_of_range& e) {
62095       {
62096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62097       };
62098     } catch (std::exception& e) {
62099       {
62100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62101       };
62102     } catch (...) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62105       };
62106     }
62107   }
62108 }
62109
62110
62111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62113   float arg2 ;
62114   Dali::Dimension::Type arg3 ;
62115   SwigDirector_ViewImpl *darg = 0;
62116
62117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62118   arg2 = (float)jarg2;
62119   arg3 = (Dali::Dimension::Type)jarg3;
62120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62121   {
62122     try {
62123       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62131       };
62132     } catch (...) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62135       };
62136     }
62137   }
62138 }
62139
62140
62141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62143
62144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62145   {
62146     try {
62147       (arg1)->OnInitialize();
62148     } catch (std::out_of_range& e) {
62149       {
62150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62151       };
62152     } catch (std::exception& e) {
62153       {
62154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62155       };
62156     } catch (...) {
62157       {
62158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62159       };
62160     }
62161   }
62162 }
62163
62164
62165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62167
62168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62169   {
62170     try {
62171       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62172     } catch (std::out_of_range& e) {
62173       {
62174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62175       };
62176     } catch (std::exception& e) {
62177       {
62178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62179       };
62180     } catch (...) {
62181       {
62182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62183       };
62184     }
62185   }
62186 }
62187
62188
62189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62191   Dali::Actor *arg2 = 0 ;
62192
62193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62194   arg2 = (Dali::Actor *)jarg2;
62195   if (!arg2) {
62196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62197     return ;
62198   }
62199   {
62200     try {
62201       (arg1)->OnControlChildAdd(*arg2);
62202     } catch (std::out_of_range& e) {
62203       {
62204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62205       };
62206     } catch (std::exception& e) {
62207       {
62208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62209       };
62210     } catch (...) {
62211       {
62212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62213       };
62214     }
62215   }
62216 }
62217
62218
62219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62221   Dali::Actor *arg2 = 0 ;
62222
62223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62224   arg2 = (Dali::Actor *)jarg2;
62225   if (!arg2) {
62226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62227     return ;
62228   }
62229   {
62230     try {
62231       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62232     } catch (std::out_of_range& e) {
62233       {
62234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62235       };
62236     } catch (std::exception& e) {
62237       {
62238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (...) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62243       };
62244     }
62245   }
62246 }
62247
62248
62249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62250   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62251   Dali::Actor *arg2 = 0 ;
62252
62253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62254   arg2 = (Dali::Actor *)jarg2;
62255   if (!arg2) {
62256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62257     return ;
62258   }
62259   {
62260     try {
62261       (arg1)->OnControlChildRemove(*arg2);
62262     } catch (std::out_of_range& e) {
62263       {
62264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62265       };
62266     } catch (std::exception& e) {
62267       {
62268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62269       };
62270     } catch (...) {
62271       {
62272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62273       };
62274     }
62275   }
62276 }
62277
62278
62279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62281   Dali::Actor *arg2 = 0 ;
62282
62283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62284   arg2 = (Dali::Actor *)jarg2;
62285   if (!arg2) {
62286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62287     return ;
62288   }
62289   {
62290     try {
62291       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62292     } catch (std::out_of_range& e) {
62293       {
62294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62295       };
62296     } catch (std::exception& e) {
62297       {
62298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62299       };
62300     } catch (...) {
62301       {
62302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62303       };
62304     }
62305   }
62306 }
62307
62308
62309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62311   Dali::Toolkit::StyleManager arg2 ;
62312   Dali::StyleChange::Type arg3 ;
62313   Dali::Toolkit::StyleManager *argp2 ;
62314
62315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62316   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62317   if (!argp2) {
62318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62319     return ;
62320   }
62321   arg2 = *argp2;
62322   arg3 = (Dali::StyleChange::Type)jarg3;
62323   {
62324     try {
62325       (arg1)->OnStyleChange(arg2,arg3);
62326     } catch (std::out_of_range& e) {
62327       {
62328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62329       };
62330     } catch (std::exception& e) {
62331       {
62332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62333       };
62334     } catch (...) {
62335       {
62336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62337       };
62338     }
62339   }
62340 }
62341
62342
62343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62345   Dali::Toolkit::StyleManager arg2 ;
62346   Dali::StyleChange::Type arg3 ;
62347   Dali::Toolkit::StyleManager *argp2 ;
62348
62349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62350   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62351   if (!argp2) {
62352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62353     return ;
62354   }
62355   arg2 = *argp2;
62356   arg3 = (Dali::StyleChange::Type)jarg3;
62357   {
62358     try {
62359       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62360     } catch (std::out_of_range& e) {
62361       {
62362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62363       };
62364     } catch (std::exception& e) {
62365       {
62366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62367       };
62368     } catch (...) {
62369       {
62370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62371       };
62372     }
62373   }
62374 }
62375
62376
62377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62378   unsigned int jresult ;
62379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62380   bool result;
62381
62382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62383   {
62384     try {
62385       result = (bool)(arg1)->OnAccessibilityActivated();
62386     } catch (std::out_of_range& e) {
62387       {
62388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62389       };
62390     } catch (std::exception& e) {
62391       {
62392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62393       };
62394     } catch (...) {
62395       {
62396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62397       };
62398     }
62399   }
62400   jresult = result;
62401   return jresult;
62402 }
62403
62404
62405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62406   unsigned int jresult ;
62407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62408   bool result;
62409
62410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62411   {
62412     try {
62413       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62414     } catch (std::out_of_range& e) {
62415       {
62416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62417       };
62418     } catch (std::exception& e) {
62419       {
62420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (...) {
62423       {
62424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62425       };
62426     }
62427   }
62428   jresult = result;
62429   return jresult;
62430 }
62431
62432
62433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62434   unsigned int jresult ;
62435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62436   Dali::PanGesture arg2 ;
62437   Dali::PanGesture *argp2 ;
62438   bool result;
62439
62440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62441   argp2 = (Dali::PanGesture *)jarg2;
62442   if (!argp2) {
62443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62444     return 0;
62445   }
62446   arg2 = *argp2;
62447   {
62448     try {
62449       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62450     } catch (std::out_of_range& e) {
62451       {
62452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62453       };
62454     } catch (std::exception& e) {
62455       {
62456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62457       };
62458     } catch (...) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62461       };
62462     }
62463   }
62464   jresult = result;
62465   return jresult;
62466 }
62467
62468
62469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62470   unsigned int jresult ;
62471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62472   Dali::PanGesture arg2 ;
62473   Dali::PanGesture *argp2 ;
62474   bool result;
62475
62476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62477   argp2 = (Dali::PanGesture *)jarg2;
62478   if (!argp2) {
62479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62480     return 0;
62481   }
62482   arg2 = *argp2;
62483   {
62484     try {
62485       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (...) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62497       };
62498     }
62499   }
62500   jresult = result;
62501   return jresult;
62502 }
62503
62504
62505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62506   unsigned int jresult ;
62507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62508   Dali::TouchEvent *arg2 = 0 ;
62509   bool result;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   arg2 = (Dali::TouchEvent *)jarg2;
62513   if (!arg2) {
62514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62515     return 0;
62516   }
62517   {
62518     try {
62519       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62520     } catch (std::out_of_range& e) {
62521       {
62522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62523       };
62524     } catch (std::exception& e) {
62525       {
62526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62527       };
62528     } catch (...) {
62529       {
62530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62531       };
62532     }
62533   }
62534   jresult = result;
62535   return jresult;
62536 }
62537
62538
62539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62540   unsigned int jresult ;
62541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62542   Dali::TouchEvent *arg2 = 0 ;
62543   bool result;
62544
62545   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62546   arg2 = (Dali::TouchEvent *)jarg2;
62547   if (!arg2) {
62548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62549     return 0;
62550   }
62551   {
62552     try {
62553       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62554     } catch (std::out_of_range& e) {
62555       {
62556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62557       };
62558     } catch (std::exception& e) {
62559       {
62560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62561       };
62562     } catch (...) {
62563       {
62564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62565       };
62566     }
62567   }
62568   jresult = result;
62569   return jresult;
62570 }
62571
62572
62573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62574   unsigned int jresult ;
62575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62576   bool arg2 ;
62577   bool result;
62578
62579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62580   arg2 = jarg2 ? true : false;
62581   {
62582     try {
62583       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62584     } catch (std::out_of_range& e) {
62585       {
62586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62587       };
62588     } catch (std::exception& e) {
62589       {
62590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62591       };
62592     } catch (...) {
62593       {
62594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62595       };
62596     }
62597   }
62598   jresult = result;
62599   return jresult;
62600 }
62601
62602
62603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62604   unsigned int jresult ;
62605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62606   bool arg2 ;
62607   bool result;
62608
62609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62610   arg2 = jarg2 ? true : false;
62611   {
62612     try {
62613       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62614     } catch (std::out_of_range& e) {
62615       {
62616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62617       };
62618     } catch (std::exception& e) {
62619       {
62620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (...) {
62623       {
62624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62625       };
62626     }
62627   }
62628   jresult = result;
62629   return jresult;
62630 }
62631
62632
62633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62634   unsigned int jresult ;
62635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62636   bool result;
62637
62638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62639   {
62640     try {
62641       result = (bool)(arg1)->OnAccessibilityZoom();
62642     } catch (std::out_of_range& e) {
62643       {
62644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62645       };
62646     } catch (std::exception& e) {
62647       {
62648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62649       };
62650     } catch (...) {
62651       {
62652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62653       };
62654     }
62655   }
62656   jresult = result;
62657   return jresult;
62658 }
62659
62660
62661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62662   unsigned int jresult ;
62663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62664   bool result;
62665
62666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62667   {
62668     try {
62669       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62670     } catch (std::out_of_range& e) {
62671       {
62672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62673       };
62674     } catch (std::exception& e) {
62675       {
62676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62677       };
62678     } catch (...) {
62679       {
62680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62681       };
62682     }
62683   }
62684   jresult = result;
62685   return jresult;
62686 }
62687
62688
62689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62691
62692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62693   {
62694     try {
62695       (arg1)->OnKeyInputFocusGained();
62696     } catch (std::out_of_range& e) {
62697       {
62698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62699       };
62700     } catch (std::exception& e) {
62701       {
62702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62703       };
62704     } catch (...) {
62705       {
62706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62707       };
62708     }
62709   }
62710 }
62711
62712
62713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62715
62716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62717   {
62718     try {
62719       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62720     } catch (std::out_of_range& e) {
62721       {
62722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62723       };
62724     } catch (std::exception& e) {
62725       {
62726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62727       };
62728     } catch (...) {
62729       {
62730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62731       };
62732     }
62733   }
62734 }
62735
62736
62737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62739
62740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62741   {
62742     try {
62743       (arg1)->OnKeyInputFocusLost();
62744     } catch (std::out_of_range& e) {
62745       {
62746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62747       };
62748     } catch (std::exception& e) {
62749       {
62750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62751       };
62752     } catch (...) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62755       };
62756     }
62757   }
62758 }
62759
62760
62761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62763
62764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62765   {
62766     try {
62767       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62768     } catch (std::out_of_range& e) {
62769       {
62770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62771       };
62772     } catch (std::exception& e) {
62773       {
62774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62779       };
62780     }
62781   }
62782 }
62783
62784
62785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62786   void * jresult ;
62787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62788   Dali::Actor arg2 ;
62789   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62790   bool arg4 ;
62791   Dali::Actor *argp2 ;
62792   Dali::Actor result;
62793
62794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62795   argp2 = (Dali::Actor *)jarg2;
62796   if (!argp2) {
62797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62798     return 0;
62799   }
62800   arg2 = *argp2;
62801   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62802   arg4 = jarg4 ? true : false;
62803   {
62804     try {
62805       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62806     } catch (std::out_of_range& e) {
62807       {
62808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62809       };
62810     } catch (std::exception& e) {
62811       {
62812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62813       };
62814     } catch (...) {
62815       {
62816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62817       };
62818     }
62819   }
62820   jresult = new Dali::Actor((const Dali::Actor &)result);
62821   return jresult;
62822 }
62823
62824
62825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62826   void * jresult ;
62827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62828   Dali::Actor arg2 ;
62829   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62830   bool arg4 ;
62831   Dali::Actor *argp2 ;
62832   Dali::Actor result;
62833
62834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62835   argp2 = (Dali::Actor *)jarg2;
62836   if (!argp2) {
62837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62838     return 0;
62839   }
62840   arg2 = *argp2;
62841   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62842   arg4 = jarg4 ? true : false;
62843   {
62844     try {
62845       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62846     } catch (std::out_of_range& e) {
62847       {
62848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62849       };
62850     } catch (std::exception& e) {
62851       {
62852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62857       };
62858     }
62859   }
62860   jresult = new Dali::Actor((const Dali::Actor &)result);
62861   return jresult;
62862 }
62863
62864
62865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62867   Dali::Actor arg2 ;
62868   Dali::Actor *argp2 ;
62869
62870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62871   argp2 = (Dali::Actor *)jarg2;
62872   if (!argp2) {
62873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62874     return ;
62875   }
62876   arg2 = *argp2;
62877   {
62878     try {
62879       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62880     } catch (std::out_of_range& e) {
62881       {
62882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62883       };
62884     } catch (std::exception& e) {
62885       {
62886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62887       };
62888     } catch (...) {
62889       {
62890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62891       };
62892     }
62893   }
62894 }
62895
62896
62897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62898   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62899   Dali::Actor arg2 ;
62900   Dali::Actor *argp2 ;
62901
62902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62903   argp2 = (Dali::Actor *)jarg2;
62904   if (!argp2) {
62905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62906     return ;
62907   }
62908   arg2 = *argp2;
62909   {
62910     try {
62911       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62912     } catch (std::out_of_range& e) {
62913       {
62914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62915       };
62916     } catch (std::exception& e) {
62917       {
62918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62919       };
62920     } catch (...) {
62921       {
62922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62923       };
62924     }
62925   }
62926 }
62927
62928
62929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62930   unsigned int jresult ;
62931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62932   bool result;
62933
62934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62935   {
62936     try {
62937       result = (bool)(arg1)->OnKeyboardEnter();
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62949       };
62950     }
62951   }
62952   jresult = result;
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62958   unsigned int jresult ;
62959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62960   bool result;
62961
62962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62963   {
62964     try {
62965       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62966     } catch (std::out_of_range& e) {
62967       {
62968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62969       };
62970     } catch (std::exception& e) {
62971       {
62972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (...) {
62975       {
62976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62977       };
62978     }
62979   }
62980   jresult = result;
62981   return jresult;
62982 }
62983
62984
62985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62987   Dali::PinchGesture *arg2 = 0 ;
62988
62989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62990   arg2 = (Dali::PinchGesture *)jarg2;
62991   if (!arg2) {
62992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62993     return ;
62994   }
62995   {
62996     try {
62997       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (...) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63009       };
63010     }
63011   }
63012 }
63013
63014
63015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63017   Dali::PinchGesture *arg2 = 0 ;
63018
63019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63020   arg2 = (Dali::PinchGesture *)jarg2;
63021   if (!arg2) {
63022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63023     return ;
63024   }
63025   {
63026     try {
63027       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63028     } catch (std::out_of_range& e) {
63029       {
63030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63031       };
63032     } catch (std::exception& e) {
63033       {
63034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63035       };
63036     } catch (...) {
63037       {
63038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63039       };
63040     }
63041   }
63042 }
63043
63044
63045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63047   Dali::PanGesture *arg2 = 0 ;
63048
63049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63050   arg2 = (Dali::PanGesture *)jarg2;
63051   if (!arg2) {
63052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63053     return ;
63054   }
63055   {
63056     try {
63057       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63058     } catch (std::out_of_range& e) {
63059       {
63060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63061       };
63062     } catch (std::exception& e) {
63063       {
63064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63065       };
63066     } catch (...) {
63067       {
63068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63069       };
63070     }
63071   }
63072 }
63073
63074
63075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63077   Dali::PanGesture *arg2 = 0 ;
63078
63079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63080   arg2 = (Dali::PanGesture *)jarg2;
63081   if (!arg2) {
63082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63083     return ;
63084   }
63085   {
63086     try {
63087       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63088     } catch (std::out_of_range& e) {
63089       {
63090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63091       };
63092     } catch (std::exception& e) {
63093       {
63094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63095       };
63096     } catch (...) {
63097       {
63098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63099       };
63100     }
63101   }
63102 }
63103
63104
63105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63107   Dali::TapGesture *arg2 = 0 ;
63108
63109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63110   arg2 = (Dali::TapGesture *)jarg2;
63111   if (!arg2) {
63112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63113     return ;
63114   }
63115   {
63116     try {
63117       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63118     } catch (std::out_of_range& e) {
63119       {
63120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63121       };
63122     } catch (std::exception& e) {
63123       {
63124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63125       };
63126     } catch (...) {
63127       {
63128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63129       };
63130     }
63131   }
63132 }
63133
63134
63135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63137   Dali::TapGesture *arg2 = 0 ;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   arg2 = (Dali::TapGesture *)jarg2;
63141   if (!arg2) {
63142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63143     return ;
63144   }
63145   {
63146     try {
63147       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63148     } catch (std::out_of_range& e) {
63149       {
63150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (std::exception& e) {
63153       {
63154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63159       };
63160     }
63161   }
63162 }
63163
63164
63165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63167   Dali::LongPressGesture *arg2 = 0 ;
63168
63169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63170   arg2 = (Dali::LongPressGesture *)jarg2;
63171   if (!arg2) {
63172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63173     return ;
63174   }
63175   {
63176     try {
63177       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (...) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63189       };
63190     }
63191   }
63192 }
63193
63194
63195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63197   Dali::LongPressGesture *arg2 = 0 ;
63198
63199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63200   arg2 = (Dali::LongPressGesture *)jarg2;
63201   if (!arg2) {
63202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63203     return ;
63204   }
63205   {
63206     try {
63207       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63208     } catch (std::out_of_range& e) {
63209       {
63210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (std::exception& e) {
63213       {
63214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63215       };
63216     } catch (...) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63219       };
63220     }
63221   }
63222 }
63223
63224
63225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63227   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63228   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63229
63230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63231   arg2 = (Dali::SlotObserver *)jarg2;
63232   arg3 = (Dali::CallbackBase *)jarg3;
63233   {
63234     try {
63235       (arg1)->SignalConnected(arg2,arg3);
63236     } catch (std::out_of_range& e) {
63237       {
63238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63239       };
63240     } catch (std::exception& e) {
63241       {
63242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63243       };
63244     } catch (...) {
63245       {
63246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63247       };
63248     }
63249   }
63250 }
63251
63252
63253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63255   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63256   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63257
63258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63259   arg2 = (Dali::SlotObserver *)jarg2;
63260   arg3 = (Dali::CallbackBase *)jarg3;
63261   {
63262     try {
63263       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63264     } catch (std::out_of_range& e) {
63265       {
63266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63267       };
63268     } catch (std::exception& e) {
63269       {
63270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63271       };
63272     } catch (...) {
63273       {
63274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63275       };
63276     }
63277   }
63278 }
63279
63280
63281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63283   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63284   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63285
63286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63287   arg2 = (Dali::SlotObserver *)jarg2;
63288   arg3 = (Dali::CallbackBase *)jarg3;
63289   {
63290     try {
63291       (arg1)->SignalDisconnected(arg2,arg3);
63292     } catch (std::out_of_range& e) {
63293       {
63294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63295       };
63296     } catch (std::exception& e) {
63297       {
63298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63299       };
63300     } catch (...) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63303       };
63304     }
63305   }
63306 }
63307
63308
63309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63311   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63312   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63313
63314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63315   arg2 = (Dali::SlotObserver *)jarg2;
63316   arg3 = (Dali::CallbackBase *)jarg3;
63317   {
63318     try {
63319       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63320     } catch (std::out_of_range& e) {
63321       {
63322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63323       };
63324     } catch (std::exception& e) {
63325       {
63326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63327       };
63328     } catch (...) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63331       };
63332     }
63333   }
63334 }
63335
63336
63337 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) {
63338   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63339   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63340   if (director) {
63341     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);
63342   }
63343 }
63344
63345
63346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63347   void * jresult ;
63348   Dali::Toolkit::Control *arg1 = 0 ;
63349   Dali::Toolkit::Internal::Control *result = 0 ;
63350
63351   arg1 = (Dali::Toolkit::Control *)jarg1;
63352   if (!arg1) {
63353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63354     return 0;
63355   }
63356   {
63357     try {
63358       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63359     } catch (std::out_of_range& e) {
63360       {
63361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (std::exception& e) {
63364       {
63365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63370       };
63371     }
63372   }
63373   jresult = (void *)result;
63374   return jresult;
63375 }
63376
63377
63378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63379   int jresult ;
63380   int result;
63381
63382   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63383   jresult = (int)result;
63384   return jresult;
63385 }
63386
63387
63388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63389   int jresult ;
63390   int result;
63391
63392   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63393   jresult = (int)result;
63394   return jresult;
63395 }
63396
63397
63398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63399   int jresult ;
63400   int result;
63401
63402   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63403   jresult = (int)result;
63404   return jresult;
63405 }
63406
63407
63408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63409   int jresult ;
63410   int result;
63411
63412   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63413   jresult = (int)result;
63414   return jresult;
63415 }
63416
63417
63418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63419   int jresult ;
63420   int result;
63421
63422   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63423   jresult = (int)result;
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63429   void * jresult ;
63430   Dali::Toolkit::Control::Property *result = 0 ;
63431
63432   {
63433     try {
63434       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (...) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63446       };
63447     }
63448   }
63449   jresult = (void *)result;
63450   return jresult;
63451 }
63452
63453
63454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63455   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63456
63457   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63458   {
63459     try {
63460       delete arg1;
63461     } catch (std::out_of_range& e) {
63462       {
63463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63464       };
63465     } catch (std::exception& e) {
63466       {
63467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63468       };
63469     } catch (...) {
63470       {
63471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63472       };
63473     }
63474   }
63475 }
63476
63477
63478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63479   void * jresult ;
63480   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63481
63482   {
63483     try {
63484       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63485     } catch (std::out_of_range& e) {
63486       {
63487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63488       };
63489     } catch (std::exception& e) {
63490       {
63491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63496       };
63497     }
63498   }
63499   jresult = (void *)result;
63500   return jresult;
63501 }
63502
63503
63504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63505   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63506
63507   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63508   {
63509     try {
63510       delete arg1;
63511     } catch (std::out_of_range& e) {
63512       {
63513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63514       };
63515     } catch (std::exception& e) {
63516       {
63517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63522       };
63523     }
63524   }
63525 }
63526
63527
63528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63529   void * jresult ;
63530   Dali::Toolkit::Control result;
63531
63532   {
63533     try {
63534       result = Dali::Toolkit::Control::New();
63535     } catch (std::out_of_range& e) {
63536       {
63537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63538       };
63539     } catch (std::exception& e) {
63540       {
63541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (...) {
63544       {
63545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63546       };
63547     }
63548   }
63549   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63550   return jresult;
63551 }
63552
63553
63554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63555   void * jresult ;
63556   Dali::Toolkit::Control *result = 0 ;
63557
63558   {
63559     try {
63560       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63561     } catch (std::out_of_range& e) {
63562       {
63563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63564       };
63565     } catch (std::exception& e) {
63566       {
63567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63568       };
63569     } catch (...) {
63570       {
63571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63572       };
63573     }
63574   }
63575   jresult = (void *)result;
63576   return jresult;
63577 }
63578
63579
63580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63581   void * jresult ;
63582   Dali::Toolkit::Control *arg1 = 0 ;
63583   Dali::Toolkit::Control *result = 0 ;
63584
63585   arg1 = (Dali::Toolkit::Control *)jarg1;
63586   if (!arg1) {
63587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63588     return 0;
63589   }
63590   {
63591     try {
63592       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63593     } catch (std::out_of_range& e) {
63594       {
63595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63596       };
63597     } catch (std::exception& e) {
63598       {
63599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63600       };
63601     } catch (...) {
63602       {
63603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63604       };
63605     }
63606   }
63607   jresult = (void *)result;
63608   return jresult;
63609 }
63610
63611
63612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63613   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63614
63615   arg1 = (Dali::Toolkit::Control *)jarg1;
63616   {
63617     try {
63618       delete arg1;
63619     } catch (std::out_of_range& e) {
63620       {
63621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63622       };
63623     } catch (std::exception& e) {
63624       {
63625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63630       };
63631     }
63632   }
63633 }
63634
63635
63636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63637   void * jresult ;
63638   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63639   Dali::Toolkit::Control *arg2 = 0 ;
63640   Dali::Toolkit::Control *result = 0 ;
63641
63642   arg1 = (Dali::Toolkit::Control *)jarg1;
63643   arg2 = (Dali::Toolkit::Control *)jarg2;
63644   if (!arg2) {
63645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63646     return 0;
63647   }
63648   {
63649     try {
63650       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63651     } catch (std::out_of_range& e) {
63652       {
63653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63654       };
63655     } catch (std::exception& e) {
63656       {
63657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63658       };
63659     } catch (...) {
63660       {
63661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63662       };
63663     }
63664   }
63665   jresult = (void *)result;
63666   return jresult;
63667 }
63668
63669
63670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63671   void * jresult ;
63672   Dali::BaseHandle arg1 ;
63673   Dali::BaseHandle *argp1 ;
63674   Dali::Toolkit::Control result;
63675
63676   argp1 = (Dali::BaseHandle *)jarg1;
63677   if (!argp1) {
63678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63679     return 0;
63680   }
63681   arg1 = *argp1;
63682   {
63683     try {
63684       result = Dali::Toolkit::Control::DownCast(arg1);
63685     } catch (std::out_of_range& e) {
63686       {
63687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63688       };
63689     } catch (std::exception& e) {
63690       {
63691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63692       };
63693     } catch (...) {
63694       {
63695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63696       };
63697     }
63698   }
63699   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63700   return jresult;
63701 }
63702
63703
63704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63705   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63706
63707   arg1 = (Dali::Toolkit::Control *)jarg1;
63708   {
63709     try {
63710       (arg1)->SetKeyInputFocus();
63711     } catch (std::out_of_range& e) {
63712       {
63713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63714       };
63715     } catch (std::exception& e) {
63716       {
63717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63718       };
63719     } catch (...) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63722       };
63723     }
63724   }
63725 }
63726
63727
63728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63729   unsigned int jresult ;
63730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63731   bool result;
63732
63733   arg1 = (Dali::Toolkit::Control *)jarg1;
63734   {
63735     try {
63736       result = (bool)(arg1)->HasKeyInputFocus();
63737     } catch (std::out_of_range& e) {
63738       {
63739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63740       };
63741     } catch (std::exception& e) {
63742       {
63743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (...) {
63746       {
63747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63748       };
63749     }
63750   }
63751   jresult = result;
63752   return jresult;
63753 }
63754
63755
63756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63757   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63758
63759   arg1 = (Dali::Toolkit::Control *)jarg1;
63760   {
63761     try {
63762       (arg1)->ClearKeyInputFocus();
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63770       };
63771     } catch (...) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63774       };
63775     }
63776   }
63777 }
63778
63779
63780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63781   void * jresult ;
63782   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63783   Dali::PinchGestureDetector result;
63784
63785   arg1 = (Dali::Toolkit::Control *)jarg1;
63786   {
63787     try {
63788       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63789     } catch (std::out_of_range& e) {
63790       {
63791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63792       };
63793     } catch (std::exception& e) {
63794       {
63795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63796       };
63797     } catch (...) {
63798       {
63799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63800       };
63801     }
63802   }
63803   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63804   return jresult;
63805 }
63806
63807
63808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63809   void * jresult ;
63810   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63811   Dali::PanGestureDetector result;
63812
63813   arg1 = (Dali::Toolkit::Control *)jarg1;
63814   {
63815     try {
63816       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63817     } catch (std::out_of_range& e) {
63818       {
63819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63820       };
63821     } catch (std::exception& e) {
63822       {
63823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63824       };
63825     } catch (...) {
63826       {
63827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63828       };
63829     }
63830   }
63831   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63832   return jresult;
63833 }
63834
63835
63836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63837   void * jresult ;
63838   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63839   Dali::TapGestureDetector result;
63840
63841   arg1 = (Dali::Toolkit::Control *)jarg1;
63842   {
63843     try {
63844       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63845     } catch (std::out_of_range& e) {
63846       {
63847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63848       };
63849     } catch (std::exception& e) {
63850       {
63851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (...) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63856       };
63857     }
63858   }
63859   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63860   return jresult;
63861 }
63862
63863
63864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63865   void * jresult ;
63866   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63867   Dali::LongPressGestureDetector result;
63868
63869   arg1 = (Dali::Toolkit::Control *)jarg1;
63870   {
63871     try {
63872       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63873     } catch (std::out_of_range& e) {
63874       {
63875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63876       };
63877     } catch (std::exception& e) {
63878       {
63879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63880       };
63881     } catch (...) {
63882       {
63883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63884       };
63885     }
63886   }
63887   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63888   return jresult;
63889 }
63890
63891
63892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63894   std::string *arg2 = 0 ;
63895
63896   arg1 = (Dali::Toolkit::Control *)jarg1;
63897   if (!jarg2) {
63898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63899     return ;
63900   }
63901   std::string arg2_str(jarg2);
63902   arg2 = &arg2_str;
63903   {
63904     try {
63905       (arg1)->SetStyleName((std::string const &)*arg2);
63906     } catch (std::out_of_range& e) {
63907       {
63908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63909       };
63910     } catch (std::exception& e) {
63911       {
63912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63913       };
63914     } catch (...) {
63915       {
63916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63917       };
63918     }
63919   }
63920
63921   //argout typemap for const std::string&
63922
63923 }
63924
63925
63926 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63927   char * jresult ;
63928   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63929   std::string *result = 0 ;
63930
63931   arg1 = (Dali::Toolkit::Control *)jarg1;
63932   {
63933     try {
63934       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63935     } catch (std::out_of_range& e) {
63936       {
63937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63938       };
63939     } catch (std::exception& e) {
63940       {
63941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63942       };
63943     } catch (...) {
63944       {
63945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63946       };
63947     }
63948   }
63949   jresult = SWIG_csharp_string_callback(result->c_str());
63950   return jresult;
63951 }
63952
63953
63954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63955   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63956   Dali::Vector4 *arg2 = 0 ;
63957
63958   arg1 = (Dali::Toolkit::Control *)jarg1;
63959   arg2 = (Dali::Vector4 *)jarg2;
63960   if (!arg2) {
63961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63962     return ;
63963   }
63964   {
63965     try {
63966       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63967     } catch (std::out_of_range& e) {
63968       {
63969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63970       };
63971     } catch (std::exception& e) {
63972       {
63973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63974       };
63975     } catch (...) {
63976       {
63977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63978       };
63979     }
63980   }
63981 }
63982
63983
63984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63985   void * jresult ;
63986   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63987   Dali::Vector4 result;
63988
63989   arg1 = (Dali::Toolkit::Control *)jarg1;
63990   {
63991     try {
63992       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63993     } catch (std::out_of_range& e) {
63994       {
63995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63996       };
63997     } catch (std::exception& e) {
63998       {
63999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64000       };
64001     } catch (...) {
64002       {
64003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64004       };
64005     }
64006   }
64007   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64008   return jresult;
64009 }
64010
64011
64012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
64013   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64014   Dali::Image arg2 ;
64015   Dali::Image *argp2 ;
64016
64017   arg1 = (Dali::Toolkit::Control *)jarg1;
64018   argp2 = (Dali::Image *)jarg2;
64019   if (!argp2) {
64020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64021     return ;
64022   }
64023   arg2 = *argp2;
64024   {
64025     try {
64026       (arg1)->SetBackgroundImage(arg2);
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64038       };
64039     }
64040   }
64041 }
64042
64043
64044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64045   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64046
64047   arg1 = (Dali::Toolkit::Control *)jarg1;
64048   {
64049     try {
64050       (arg1)->ClearBackground();
64051     } catch (std::out_of_range& e) {
64052       {
64053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64054       };
64055     } catch (std::exception& e) {
64056       {
64057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64058       };
64059     } catch (...) {
64060       {
64061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64062       };
64063     }
64064   }
64065 }
64066
64067
64068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64069   void * jresult ;
64070   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64071   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64072
64073   arg1 = (Dali::Toolkit::Control *)jarg1;
64074   {
64075     try {
64076       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64077     } catch (std::out_of_range& e) {
64078       {
64079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64080       };
64081     } catch (std::exception& e) {
64082       {
64083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64084       };
64085     } catch (...) {
64086       {
64087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64088       };
64089     }
64090   }
64091   jresult = (void *)result;
64092   return jresult;
64093 }
64094
64095
64096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64097   void * jresult ;
64098   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64099   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64100
64101   arg1 = (Dali::Toolkit::Control *)jarg1;
64102   {
64103     try {
64104       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64105     } catch (std::out_of_range& e) {
64106       {
64107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64108       };
64109     } catch (std::exception& e) {
64110       {
64111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64112       };
64113     } catch (...) {
64114       {
64115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64116       };
64117     }
64118   }
64119   jresult = (void *)result;
64120   return jresult;
64121 }
64122
64123
64124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64125   void * jresult ;
64126   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64127   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64128
64129   arg1 = (Dali::Toolkit::Control *)jarg1;
64130   {
64131     try {
64132       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64133     } catch (std::out_of_range& e) {
64134       {
64135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64136       };
64137     } catch (std::exception& e) {
64138       {
64139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64140       };
64141     } catch (...) {
64142       {
64143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64144       };
64145     }
64146   }
64147   jresult = (void *)result;
64148   return jresult;
64149 }
64150
64151
64152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64153   void * jresult ;
64154   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64155   Dali::Toolkit::Control *result = 0 ;
64156
64157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64158   if (!arg1) {
64159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64160     return 0;
64161   }
64162   {
64163     try {
64164       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64165     } catch (std::out_of_range& e) {
64166       {
64167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64168       };
64169     } catch (std::exception& e) {
64170       {
64171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64172       };
64173     } catch (...) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64176       };
64177     }
64178   }
64179   jresult = (void *)result;
64180   return jresult;
64181 }
64182
64183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64184   void * jresult ;
64185   Dali::Toolkit::Control *arg1 = 0 ;
64186   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64187
64188   arg1 = (Dali::Toolkit::Control *)jarg1;
64189   if (!arg1) {
64190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64191     return 0;
64192   }
64193   {
64194     try {
64195       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64196     } catch (std::out_of_range& e) {
64197       {
64198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64199       };
64200     } catch (std::exception& e) {
64201       {
64202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64203       };
64204     } catch (...) {
64205       {
64206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64207       };
64208     }
64209   }
64210   jresult = (void *)result;
64211   return jresult;
64212 }
64213
64214
64215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64216   unsigned int jresult ;
64217   Dali::Toolkit::Control *arg1 = 0 ;
64218   bool result;
64219
64220   arg1 = (Dali::Toolkit::Control *)jarg1;
64221   if (!arg1) {
64222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64223     return 0;
64224   }
64225   {
64226     try {
64227       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64228     } catch (std::out_of_range& e) {
64229       {
64230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64231       };
64232     } catch (std::exception& e) {
64233       {
64234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (...) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64239       };
64240     }
64241   }
64242   jresult = result;
64243   return jresult;
64244 }
64245
64246
64247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64248   void * jresult ;
64249   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64250
64251   {
64252     try {
64253       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64254     } catch (std::out_of_range& e) {
64255       {
64256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64257       };
64258     } catch (std::exception& e) {
64259       {
64260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64261       };
64262     } catch (...) {
64263       {
64264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64265       };
64266     }
64267   }
64268   jresult = (void *)result;
64269   return jresult;
64270 }
64271
64272
64273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64274   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64275
64276   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64277   {
64278     try {
64279       delete arg1;
64280     } catch (std::out_of_range& e) {
64281       {
64282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64283       };
64284     } catch (std::exception& e) {
64285       {
64286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64287       };
64288     } catch (...) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64291       };
64292     }
64293   }
64294 }
64295
64296
64297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64298   void * jresult ;
64299   Dali::Toolkit::KeyInputFocusManager result;
64300
64301   {
64302     try {
64303       result = Dali::Toolkit::KeyInputFocusManager::Get();
64304     } catch (std::out_of_range& e) {
64305       {
64306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64307       };
64308     } catch (std::exception& e) {
64309       {
64310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64311       };
64312     } catch (...) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64315       };
64316     }
64317   }
64318   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64319   return jresult;
64320 }
64321
64322
64323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64324   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64325   Dali::Toolkit::Control arg2 ;
64326   Dali::Toolkit::Control *argp2 ;
64327
64328   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64329   argp2 = (Dali::Toolkit::Control *)jarg2;
64330   if (!argp2) {
64331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64332     return ;
64333   }
64334   arg2 = *argp2;
64335   {
64336     try {
64337       (arg1)->SetFocus(arg2);
64338     } catch (std::out_of_range& e) {
64339       {
64340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64341       };
64342     } catch (std::exception& e) {
64343       {
64344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64345       };
64346     } catch (...) {
64347       {
64348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64349       };
64350     }
64351   }
64352 }
64353
64354
64355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64356   void * jresult ;
64357   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64358   Dali::Toolkit::Control result;
64359
64360   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64361   {
64362     try {
64363       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64364     } catch (std::out_of_range& e) {
64365       {
64366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64367       };
64368     } catch (std::exception& e) {
64369       {
64370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (...) {
64373       {
64374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64375       };
64376     }
64377   }
64378   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64379   return jresult;
64380 }
64381
64382
64383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64384   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64385   Dali::Toolkit::Control arg2 ;
64386   Dali::Toolkit::Control *argp2 ;
64387
64388   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64389   argp2 = (Dali::Toolkit::Control *)jarg2;
64390   if (!argp2) {
64391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64392     return ;
64393   }
64394   arg2 = *argp2;
64395   {
64396     try {
64397       (arg1)->RemoveFocus(arg2);
64398     } catch (std::out_of_range& e) {
64399       {
64400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64401       };
64402     } catch (std::exception& e) {
64403       {
64404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64405       };
64406     } catch (...) {
64407       {
64408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64409       };
64410     }
64411   }
64412 }
64413
64414
64415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64416   void * jresult ;
64417   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64418   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64419
64420   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64421   {
64422     try {
64423       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64424     } catch (std::out_of_range& e) {
64425       {
64426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64427       };
64428     } catch (std::exception& e) {
64429       {
64430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64431       };
64432     } catch (...) {
64433       {
64434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64435       };
64436     }
64437   }
64438   jresult = (void *)result;
64439   return jresult;
64440 }
64441
64442
64443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64444   void * jresult ;
64445   Dali::Toolkit::Alignment::Padding *result = 0 ;
64446
64447   {
64448     try {
64449       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64450     } catch (std::out_of_range& e) {
64451       {
64452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64453       };
64454     } catch (std::exception& e) {
64455       {
64456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64457       };
64458     } catch (...) {
64459       {
64460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64461       };
64462     }
64463   }
64464   jresult = (void *)result;
64465   return jresult;
64466 }
64467
64468
64469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64470   void * jresult ;
64471   float arg1 ;
64472   float arg2 ;
64473   float arg3 ;
64474   float arg4 ;
64475   Dali::Toolkit::Alignment::Padding *result = 0 ;
64476
64477   arg1 = (float)jarg1;
64478   arg2 = (float)jarg2;
64479   arg3 = (float)jarg3;
64480   arg4 = (float)jarg4;
64481   {
64482     try {
64483       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64484     } catch (std::out_of_range& e) {
64485       {
64486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (std::exception& e) {
64489       {
64490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64491       };
64492     } catch (...) {
64493       {
64494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64495       };
64496     }
64497   }
64498   jresult = (void *)result;
64499   return jresult;
64500 }
64501
64502
64503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left = arg2;
64510 }
64511
64512
64513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_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)->left);
64520   jresult = result;
64521   return jresult;
64522 }
64523
64524
64525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right = arg2;
64532 }
64533
64534
64535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_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)->right);
64542   jresult = result;
64543   return jresult;
64544 }
64545
64546
64547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top = arg2;
64554 }
64555
64556
64557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_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)->top);
64564   jresult = result;
64565   return jresult;
64566 }
64567
64568
64569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64570   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64571   float arg2 ;
64572
64573   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64574   arg2 = (float)jarg2;
64575   if (arg1) (arg1)->bottom = arg2;
64576 }
64577
64578
64579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64580   float jresult ;
64581   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64582   float result;
64583
64584   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64585   result = (float) ((arg1)->bottom);
64586   jresult = result;
64587   return jresult;
64588 }
64589
64590
64591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64592   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64593
64594   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64595   {
64596     try {
64597       delete arg1;
64598     } catch (std::out_of_range& e) {
64599       {
64600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64601       };
64602     } catch (std::exception& e) {
64603       {
64604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64605       };
64606     } catch (...) {
64607       {
64608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64609       };
64610     }
64611   }
64612 }
64613
64614
64615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64616   void * jresult ;
64617   Dali::Toolkit::Alignment *result = 0 ;
64618
64619   {
64620     try {
64621       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64622     } catch (std::out_of_range& e) {
64623       {
64624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64625       };
64626     } catch (std::exception& e) {
64627       {
64628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64629       };
64630     } catch (...) {
64631       {
64632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64633       };
64634     }
64635   }
64636   jresult = (void *)result;
64637   return jresult;
64638 }
64639
64640
64641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64642   void * jresult ;
64643   Dali::Toolkit::Alignment::Type arg1 ;
64644   Dali::Toolkit::Alignment::Type arg2 ;
64645   Dali::Toolkit::Alignment result;
64646
64647   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64648   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64649   {
64650     try {
64651       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64652     } catch (std::out_of_range& e) {
64653       {
64654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64655       };
64656     } catch (std::exception& e) {
64657       {
64658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64659       };
64660     } catch (...) {
64661       {
64662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64663       };
64664     }
64665   }
64666   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64667   return jresult;
64668 }
64669
64670
64671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64672   void * jresult ;
64673   Dali::Toolkit::Alignment::Type arg1 ;
64674   Dali::Toolkit::Alignment result;
64675
64676   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64677   {
64678     try {
64679       result = Dali::Toolkit::Alignment::New(arg1);
64680     } catch (std::out_of_range& e) {
64681       {
64682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64683       };
64684     } catch (std::exception& e) {
64685       {
64686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64687       };
64688     } catch (...) {
64689       {
64690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64691       };
64692     }
64693   }
64694   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64695   return jresult;
64696 }
64697
64698
64699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64700   void * jresult ;
64701   Dali::Toolkit::Alignment result;
64702
64703   {
64704     try {
64705       result = Dali::Toolkit::Alignment::New();
64706     } catch (std::out_of_range& e) {
64707       {
64708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64709       };
64710     } catch (std::exception& e) {
64711       {
64712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64713       };
64714     } catch (...) {
64715       {
64716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64717       };
64718     }
64719   }
64720   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64721   return jresult;
64722 }
64723
64724
64725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64726   void * jresult ;
64727   Dali::Toolkit::Alignment *arg1 = 0 ;
64728   Dali::Toolkit::Alignment *result = 0 ;
64729
64730   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64731   if (!arg1) {
64732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64733     return 0;
64734   }
64735   {
64736     try {
64737       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64738     } catch (std::out_of_range& e) {
64739       {
64740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64741       };
64742     } catch (std::exception& e) {
64743       {
64744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64745       };
64746     } catch (...) {
64747       {
64748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64749       };
64750     }
64751   }
64752   jresult = (void *)result;
64753   return jresult;
64754 }
64755
64756
64757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64758   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64759
64760   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64761   {
64762     try {
64763       delete arg1;
64764     } catch (std::out_of_range& e) {
64765       {
64766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64767       };
64768     } catch (std::exception& e) {
64769       {
64770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64771       };
64772     } catch (...) {
64773       {
64774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64775       };
64776     }
64777   }
64778 }
64779
64780
64781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64782   void * jresult ;
64783   Dali::BaseHandle arg1 ;
64784   Dali::BaseHandle *argp1 ;
64785   Dali::Toolkit::Alignment result;
64786
64787   argp1 = (Dali::BaseHandle *)jarg1;
64788   if (!argp1) {
64789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64790     return 0;
64791   }
64792   arg1 = *argp1;
64793   {
64794     try {
64795       result = Dali::Toolkit::Alignment::DownCast(arg1);
64796     } catch (std::out_of_range& e) {
64797       {
64798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64799       };
64800     } catch (std::exception& e) {
64801       {
64802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64803       };
64804     } catch (...) {
64805       {
64806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64807       };
64808     }
64809   }
64810   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64811   return jresult;
64812 }
64813
64814
64815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64816   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64817   Dali::Toolkit::Alignment::Type arg2 ;
64818
64819   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64820   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64821   {
64822     try {
64823       (arg1)->SetAlignmentType(arg2);
64824     } catch (std::out_of_range& e) {
64825       {
64826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64827       };
64828     } catch (std::exception& e) {
64829       {
64830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64831       };
64832     } catch (...) {
64833       {
64834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64835       };
64836     }
64837   }
64838 }
64839
64840
64841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64842   int jresult ;
64843   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64844   Dali::Toolkit::Alignment::Type result;
64845
64846   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64847   {
64848     try {
64849       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64850     } catch (std::out_of_range& e) {
64851       {
64852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64853       };
64854     } catch (std::exception& e) {
64855       {
64856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64857       };
64858     } catch (...) {
64859       {
64860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64861       };
64862     }
64863   }
64864   jresult = (int)result;
64865   return jresult;
64866 }
64867
64868
64869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64870   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64871   Dali::Toolkit::Alignment::Scaling arg2 ;
64872
64873   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64874   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64875   {
64876     try {
64877       (arg1)->SetScaling(arg2);
64878     } catch (std::out_of_range& e) {
64879       {
64880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64881       };
64882     } catch (std::exception& e) {
64883       {
64884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64885       };
64886     } catch (...) {
64887       {
64888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64889       };
64890     }
64891   }
64892 }
64893
64894
64895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64896   int jresult ;
64897   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64898   Dali::Toolkit::Alignment::Scaling result;
64899
64900   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64901   {
64902     try {
64903       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64904     } catch (std::out_of_range& e) {
64905       {
64906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64907       };
64908     } catch (std::exception& e) {
64909       {
64910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64911       };
64912     } catch (...) {
64913       {
64914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64915       };
64916     }
64917   }
64918   jresult = (int)result;
64919   return jresult;
64920 }
64921
64922
64923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64924   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64925   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64926
64927   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64928   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64929   if (!arg2) {
64930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64931     return ;
64932   }
64933   {
64934     try {
64935       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64936     } catch (std::out_of_range& e) {
64937       {
64938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64939       };
64940     } catch (std::exception& e) {
64941       {
64942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64943       };
64944     } catch (...) {
64945       {
64946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64947       };
64948     }
64949   }
64950 }
64951
64952
64953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64954   void * jresult ;
64955   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64956   Dali::Toolkit::Alignment::Padding *result = 0 ;
64957
64958   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64959   {
64960     try {
64961       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64962     } catch (std::out_of_range& e) {
64963       {
64964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64965       };
64966     } catch (std::exception& e) {
64967       {
64968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64969       };
64970     } catch (...) {
64971       {
64972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64973       };
64974     }
64975   }
64976   jresult = (void *)result;
64977   return jresult;
64978 }
64979
64980
64981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64982   void * jresult ;
64983   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64984   Dali::Toolkit::Alignment *arg2 = 0 ;
64985   Dali::Toolkit::Alignment *result = 0 ;
64986
64987   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64988   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64989   if (!arg2) {
64990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64991     return 0;
64992   }
64993   {
64994     try {
64995       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64996     } catch (std::out_of_range& e) {
64997       {
64998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64999       };
65000     } catch (std::exception& e) {
65001       {
65002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65003       };
65004     } catch (...) {
65005       {
65006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65007       };
65008     }
65009   }
65010   jresult = (void *)result;
65011   return jresult;
65012 }
65013
65014
65015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65016   int jresult ;
65017   int result;
65018
65019   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65020   jresult = (int)result;
65021   return jresult;
65022 }
65023
65024
65025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65026   int jresult ;
65027   int result;
65028
65029   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65030   jresult = (int)result;
65031   return jresult;
65032 }
65033
65034
65035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65036   int jresult ;
65037   int result;
65038
65039   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65040   jresult = (int)result;
65041   return jresult;
65042 }
65043
65044
65045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65046   int jresult ;
65047   int result;
65048
65049   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65050   jresult = (int)result;
65051   return jresult;
65052 }
65053
65054
65055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65056   int jresult ;
65057   int result;
65058
65059   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65060   jresult = (int)result;
65061   return jresult;
65062 }
65063
65064
65065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65066   int jresult ;
65067   int result;
65068
65069   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65070   jresult = (int)result;
65071   return jresult;
65072 }
65073
65074
65075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
65076   int jresult ;
65077   int result;
65078
65079   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
65080   jresult = (int)result;
65081   return jresult;
65082 }
65083
65084
65085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
65086   int jresult ;
65087   int result;
65088
65089   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
65090   jresult = (int)result;
65091   return jresult;
65092 }
65093
65094
65095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65096   int jresult ;
65097   int result;
65098
65099   result = (int)Dali::Toolkit::Button::Property::LABEL;
65100   jresult = (int)result;
65101   return jresult;
65102 }
65103
65104
65105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65106   int jresult ;
65107   int result;
65108
65109   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65110   jresult = (int)result;
65111   return jresult;
65112 }
65113
65114
65115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65116   void * jresult ;
65117   Dali::Toolkit::Button::Property *result = 0 ;
65118
65119   {
65120     try {
65121       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65122     } catch (std::out_of_range& e) {
65123       {
65124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65125       };
65126     } catch (std::exception& e) {
65127       {
65128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (...) {
65131       {
65132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65133       };
65134     }
65135   }
65136   jresult = (void *)result;
65137   return jresult;
65138 }
65139
65140
65141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65142   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65143
65144   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65145   {
65146     try {
65147       delete arg1;
65148     } catch (std::out_of_range& e) {
65149       {
65150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65151       };
65152     } catch (std::exception& e) {
65153       {
65154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65155       };
65156     } catch (...) {
65157       {
65158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65159       };
65160     }
65161   }
65162 }
65163
65164
65165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65166   void * jresult ;
65167   Dali::Toolkit::Button *result = 0 ;
65168
65169   {
65170     try {
65171       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65172     } catch (std::out_of_range& e) {
65173       {
65174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65175       };
65176     } catch (std::exception& e) {
65177       {
65178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65179       };
65180     } catch (...) {
65181       {
65182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65183       };
65184     }
65185   }
65186   jresult = (void *)result;
65187   return jresult;
65188 }
65189
65190
65191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65192   void * jresult ;
65193   Dali::Toolkit::Button *arg1 = 0 ;
65194   Dali::Toolkit::Button *result = 0 ;
65195
65196   arg1 = (Dali::Toolkit::Button *)jarg1;
65197   if (!arg1) {
65198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65199     return 0;
65200   }
65201   {
65202     try {
65203       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65204     } catch (std::out_of_range& e) {
65205       {
65206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65207       };
65208     } catch (std::exception& e) {
65209       {
65210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65211       };
65212     } catch (...) {
65213       {
65214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65215       };
65216     }
65217   }
65218   jresult = (void *)result;
65219   return jresult;
65220 }
65221
65222
65223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65224   void * jresult ;
65225   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65226   Dali::Toolkit::Button *arg2 = 0 ;
65227   Dali::Toolkit::Button *result = 0 ;
65228
65229   arg1 = (Dali::Toolkit::Button *)jarg1;
65230   arg2 = (Dali::Toolkit::Button *)jarg2;
65231   if (!arg2) {
65232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65233     return 0;
65234   }
65235   {
65236     try {
65237       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65238     } catch (std::out_of_range& e) {
65239       {
65240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65241       };
65242     } catch (std::exception& e) {
65243       {
65244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65245       };
65246     } catch (...) {
65247       {
65248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65249       };
65250     }
65251   }
65252   jresult = (void *)result;
65253   return jresult;
65254 }
65255
65256
65257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65258   void * jresult ;
65259   Dali::BaseHandle arg1 ;
65260   Dali::BaseHandle *argp1 ;
65261   Dali::Toolkit::Button result;
65262
65263   argp1 = (Dali::BaseHandle *)jarg1;
65264   if (!argp1) {
65265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65266     return 0;
65267   }
65268   arg1 = *argp1;
65269   {
65270     try {
65271       result = Dali::Toolkit::Button::DownCast(arg1);
65272     } catch (std::out_of_range& e) {
65273       {
65274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65275       };
65276     } catch (std::exception& e) {
65277       {
65278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65279       };
65280     } catch (...) {
65281       {
65282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65283       };
65284     }
65285   }
65286   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65287   return jresult;
65288 }
65289
65290
65291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65292   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65293
65294   arg1 = (Dali::Toolkit::Button *)jarg1;
65295   {
65296     try {
65297       delete arg1;
65298     } catch (std::out_of_range& e) {
65299       {
65300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65301       };
65302     } catch (std::exception& e) {
65303       {
65304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65305       };
65306     } catch (...) {
65307       {
65308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65309       };
65310     }
65311   }
65312 }
65313
65314
65315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65316   unsigned int jresult ;
65317   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65318   bool result;
65319
65320   arg1 = (Dali::Toolkit::Button *)jarg1;
65321   {
65322     try {
65323       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65324     } catch (std::out_of_range& e) {
65325       {
65326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65327       };
65328     } catch (std::exception& e) {
65329       {
65330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65331       };
65332     } catch (...) {
65333       {
65334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65335       };
65336     }
65337   }
65338   jresult = result;
65339   return jresult;
65340 }
65341
65342
65343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65344   unsigned int jresult ;
65345   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65346   bool result;
65347
65348   arg1 = (Dali::Toolkit::Button *)jarg1;
65349   {
65350     try {
65351       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65352     } catch (std::out_of_range& e) {
65353       {
65354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65355       };
65356     } catch (std::exception& e) {
65357       {
65358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65359       };
65360     } catch (...) {
65361       {
65362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65363       };
65364     }
65365   }
65366   jresult = result;
65367   return jresult;
65368 }
65369
65370
65371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65372   float jresult ;
65373   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65374   float result;
65375
65376   arg1 = (Dali::Toolkit::Button *)jarg1;
65377   {
65378     try {
65379       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65380     } catch (std::out_of_range& e) {
65381       {
65382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65383       };
65384     } catch (std::exception& e) {
65385       {
65386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65387       };
65388     } catch (...) {
65389       {
65390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65391       };
65392     }
65393   }
65394   jresult = result;
65395   return jresult;
65396 }
65397
65398
65399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65400   float jresult ;
65401   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65402   float result;
65403
65404   arg1 = (Dali::Toolkit::Button *)jarg1;
65405   {
65406     try {
65407       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65408     } catch (std::out_of_range& e) {
65409       {
65410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65411       };
65412     } catch (std::exception& e) {
65413       {
65414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65415       };
65416     } catch (...) {
65417       {
65418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65419       };
65420     }
65421   }
65422   jresult = result;
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65428   unsigned int jresult ;
65429   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65430   bool result;
65431
65432   arg1 = (Dali::Toolkit::Button *)jarg1;
65433   {
65434     try {
65435       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65436     } catch (std::out_of_range& e) {
65437       {
65438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65439       };
65440     } catch (std::exception& e) {
65441       {
65442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65443       };
65444     } catch (...) {
65445       {
65446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65447       };
65448     }
65449   }
65450   jresult = result;
65451   return jresult;
65452 }
65453
65454
65455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65456   unsigned int jresult ;
65457   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65458   bool result;
65459
65460   arg1 = (Dali::Toolkit::Button *)jarg1;
65461   {
65462     try {
65463       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65464     } catch (std::out_of_range& e) {
65465       {
65466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65467       };
65468     } catch (std::exception& e) {
65469       {
65470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65471       };
65472     } catch (...) {
65473       {
65474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65475       };
65476     }
65477   }
65478   jresult = result;
65479   return jresult;
65480 }
65481
65482
65483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65484   float jresult ;
65485   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65486   float result;
65487
65488   arg1 = (Dali::Toolkit::Button *)jarg1;
65489   {
65490     try {
65491       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65492     } catch (std::out_of_range& e) {
65493       {
65494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65495       };
65496     } catch (std::exception& e) {
65497       {
65498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65499       };
65500     } catch (...) {
65501       {
65502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65503       };
65504     }
65505   }
65506   jresult = result;
65507   return jresult;
65508 }
65509
65510
65511 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65512   char * jresult ;
65513   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65514   std::string result;
65515
65516   arg1 = (Dali::Toolkit::Button *)jarg1;
65517   {
65518     try {
65519       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65520     } catch (std::out_of_range& e) {
65521       {
65522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (std::exception& e) {
65525       {
65526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (...) {
65529       {
65530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65531       };
65532     }
65533   }
65534   jresult = SWIG_csharp_string_callback((&result)->c_str());
65535   return jresult;
65536 }
65537
65538
65539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65540   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65541   Dali::Actor arg2 ;
65542   Dali::Actor *argp2 ;
65543
65544   arg1 = (Dali::Toolkit::Button *)jarg1;
65545   argp2 = (Dali::Actor *)jarg2;
65546   if (!argp2) {
65547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65548     return ;
65549   }
65550   arg2 = *argp2;
65551   {
65552     try {
65553       (arg1)->SetLabel(arg2);
65554     } catch (std::out_of_range& e) {
65555       {
65556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65557       };
65558     } catch (std::exception& e) {
65559       {
65560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65561       };
65562     } catch (...) {
65563       {
65564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65565       };
65566     }
65567   }
65568 }
65569
65570
65571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65572   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65573   Dali::Image arg2 ;
65574   Dali::Image *argp2 ;
65575
65576   arg1 = (Dali::Toolkit::Button *)jarg1;
65577   argp2 = (Dali::Image *)jarg2;
65578   if (!argp2) {
65579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65580     return ;
65581   }
65582   arg2 = *argp2;
65583   {
65584     try {
65585       (arg1)->SetButtonImage(arg2);
65586     } catch (std::out_of_range& e) {
65587       {
65588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65589       };
65590     } catch (std::exception& e) {
65591       {
65592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65593       };
65594     } catch (...) {
65595       {
65596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65597       };
65598     }
65599   }
65600 }
65601
65602
65603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65604   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65605   Dali::Image arg2 ;
65606   Dali::Image *argp2 ;
65607
65608   arg1 = (Dali::Toolkit::Button *)jarg1;
65609   argp2 = (Dali::Image *)jarg2;
65610   if (!argp2) {
65611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65612     return ;
65613   }
65614   arg2 = *argp2;
65615   {
65616     try {
65617       (arg1)->SetSelectedImage(arg2);
65618     } catch (std::out_of_range& e) {
65619       {
65620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65621       };
65622     } catch (std::exception& e) {
65623       {
65624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65625       };
65626     } catch (...) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65629       };
65630     }
65631   }
65632 }
65633
65634
65635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65636   void * jresult ;
65637   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65638   Dali::Actor result;
65639
65640   arg1 = (Dali::Toolkit::Button *)jarg1;
65641   {
65642     try {
65643       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65644     } catch (std::out_of_range& e) {
65645       {
65646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65647       };
65648     } catch (std::exception& e) {
65649       {
65650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65651       };
65652     } catch (...) {
65653       {
65654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65655       };
65656     }
65657   }
65658   jresult = new Dali::Actor((const Dali::Actor &)result);
65659   return jresult;
65660 }
65661
65662
65663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65664   void * jresult ;
65665   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65666   Dali::Actor result;
65667
65668   arg1 = (Dali::Toolkit::Button *)jarg1;
65669   {
65670     try {
65671       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65672     } catch (std::out_of_range& e) {
65673       {
65674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65675       };
65676     } catch (std::exception& e) {
65677       {
65678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65679       };
65680     } catch (...) {
65681       {
65682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65683       };
65684     }
65685   }
65686   jresult = new Dali::Actor((const Dali::Actor &)result);
65687   return jresult;
65688 }
65689
65690
65691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65692   void * jresult ;
65693   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65694   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65695
65696   arg1 = (Dali::Toolkit::Button *)jarg1;
65697   {
65698     try {
65699       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65700     } catch (std::out_of_range& e) {
65701       {
65702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65703       };
65704     } catch (std::exception& e) {
65705       {
65706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65707       };
65708     } catch (...) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65711       };
65712     }
65713   }
65714   jresult = (void *)result;
65715   return jresult;
65716 }
65717
65718
65719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65720   void * jresult ;
65721   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65722   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65723
65724   arg1 = (Dali::Toolkit::Button *)jarg1;
65725   {
65726     try {
65727       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65728     } catch (std::out_of_range& e) {
65729       {
65730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65731       };
65732     } catch (std::exception& e) {
65733       {
65734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65735       };
65736     } catch (...) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65739       };
65740     }
65741   }
65742   jresult = (void *)result;
65743   return jresult;
65744 }
65745
65746
65747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65748   void * jresult ;
65749   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65750   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65751
65752   arg1 = (Dali::Toolkit::Button *)jarg1;
65753   {
65754     try {
65755       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65756     } catch (std::out_of_range& e) {
65757       {
65758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65759       };
65760     } catch (std::exception& e) {
65761       {
65762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65763       };
65764     } catch (...) {
65765       {
65766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65767       };
65768     }
65769   }
65770   jresult = (void *)result;
65771   return jresult;
65772 }
65773
65774
65775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65776   void * jresult ;
65777   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65778   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65779
65780   arg1 = (Dali::Toolkit::Button *)jarg1;
65781   {
65782     try {
65783       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65784     } catch (std::out_of_range& e) {
65785       {
65786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65787       };
65788     } catch (std::exception& e) {
65789       {
65790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65791       };
65792     } catch (...) {
65793       {
65794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65795       };
65796     }
65797   }
65798   jresult = (void *)result;
65799   return jresult;
65800 }
65801
65802
65803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65804   void * jresult ;
65805   Dali::Toolkit::CheckBoxButton *result = 0 ;
65806
65807   {
65808     try {
65809       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65810     } catch (std::out_of_range& e) {
65811       {
65812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (std::exception& e) {
65815       {
65816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (...) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65821       };
65822     }
65823   }
65824   jresult = (void *)result;
65825   return jresult;
65826 }
65827
65828
65829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65830   void * jresult ;
65831   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65832   Dali::Toolkit::CheckBoxButton *result = 0 ;
65833
65834   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65835   if (!arg1) {
65836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65837     return 0;
65838   }
65839   {
65840     try {
65841       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (...) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65853       };
65854     }
65855   }
65856   jresult = (void *)result;
65857   return jresult;
65858 }
65859
65860
65861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65862   void * jresult ;
65863   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65864   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65865   Dali::Toolkit::CheckBoxButton *result = 0 ;
65866
65867   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65868   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65869   if (!arg2) {
65870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65871     return 0;
65872   }
65873   {
65874     try {
65875       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65876     } catch (std::out_of_range& e) {
65877       {
65878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65879       };
65880     } catch (std::exception& e) {
65881       {
65882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65883       };
65884     } catch (...) {
65885       {
65886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65887       };
65888     }
65889   }
65890   jresult = (void *)result;
65891   return jresult;
65892 }
65893
65894
65895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65896   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65897
65898   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65899   {
65900     try {
65901       delete arg1;
65902     } catch (std::out_of_range& e) {
65903       {
65904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65905       };
65906     } catch (std::exception& e) {
65907       {
65908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65909       };
65910     } catch (...) {
65911       {
65912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65913       };
65914     }
65915   }
65916 }
65917
65918
65919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65920   void * jresult ;
65921   Dali::Toolkit::CheckBoxButton result;
65922
65923   {
65924     try {
65925       result = Dali::Toolkit::CheckBoxButton::New();
65926     } catch (std::out_of_range& e) {
65927       {
65928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65929       };
65930     } catch (std::exception& e) {
65931       {
65932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65933       };
65934     } catch (...) {
65935       {
65936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65937       };
65938     }
65939   }
65940   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65941   return jresult;
65942 }
65943
65944
65945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65946   void * jresult ;
65947   Dali::BaseHandle arg1 ;
65948   Dali::BaseHandle *argp1 ;
65949   Dali::Toolkit::CheckBoxButton result;
65950
65951   argp1 = (Dali::BaseHandle *)jarg1;
65952   if (!argp1) {
65953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65954     return 0;
65955   }
65956   arg1 = *argp1;
65957   {
65958     try {
65959       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65960     } catch (std::out_of_range& e) {
65961       {
65962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65963       };
65964     } catch (std::exception& e) {
65965       {
65966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65967       };
65968     } catch (...) {
65969       {
65970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65971       };
65972     }
65973   }
65974   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65975   return jresult;
65976 }
65977
65978
65979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65980   int jresult ;
65981   int result;
65982
65983   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65984   jresult = (int)result;
65985   return jresult;
65986 }
65987
65988
65989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65990   int jresult ;
65991   int result;
65992
65993   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65994   jresult = (int)result;
65995   return jresult;
65996 }
65997
65998
65999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66000   int jresult ;
66001   int result;
66002
66003   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
66004   jresult = (int)result;
66005   return jresult;
66006 }
66007
66008
66009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
66010   int jresult ;
66011   int result;
66012
66013   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
66014   jresult = (int)result;
66015   return jresult;
66016 }
66017
66018
66019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
66020   int jresult ;
66021   int result;
66022
66023   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66024   jresult = (int)result;
66025   return jresult;
66026 }
66027
66028
66029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66030   void * jresult ;
66031   Dali::Toolkit::PushButton::Property *result = 0 ;
66032
66033   {
66034     try {
66035       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
66036     } catch (std::out_of_range& e) {
66037       {
66038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66039       };
66040     } catch (std::exception& e) {
66041       {
66042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66043       };
66044     } catch (...) {
66045       {
66046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66047       };
66048     }
66049   }
66050   jresult = (void *)result;
66051   return jresult;
66052 }
66053
66054
66055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
66056   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66057
66058   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
66059   {
66060     try {
66061       delete arg1;
66062     } catch (std::out_of_range& e) {
66063       {
66064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66065       };
66066     } catch (std::exception& e) {
66067       {
66068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66069       };
66070     } catch (...) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66073       };
66074     }
66075   }
66076 }
66077
66078
66079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
66080   void * jresult ;
66081   Dali::Toolkit::PushButton *result = 0 ;
66082
66083   {
66084     try {
66085       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
66086     } catch (std::out_of_range& e) {
66087       {
66088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66089       };
66090     } catch (std::exception& e) {
66091       {
66092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66093       };
66094     } catch (...) {
66095       {
66096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66097       };
66098     }
66099   }
66100   jresult = (void *)result;
66101   return jresult;
66102 }
66103
66104
66105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66106   void * jresult ;
66107   Dali::Toolkit::PushButton *arg1 = 0 ;
66108   Dali::Toolkit::PushButton *result = 0 ;
66109
66110   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66111   if (!arg1) {
66112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66113     return 0;
66114   }
66115   {
66116     try {
66117       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66118     } catch (std::out_of_range& e) {
66119       {
66120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66121       };
66122     } catch (std::exception& e) {
66123       {
66124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66125       };
66126     } catch (...) {
66127       {
66128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66129       };
66130     }
66131   }
66132   jresult = (void *)result;
66133   return jresult;
66134 }
66135
66136
66137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66138   void * jresult ;
66139   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66140   Dali::Toolkit::PushButton *arg2 = 0 ;
66141   Dali::Toolkit::PushButton *result = 0 ;
66142
66143   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66144   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66145   if (!arg2) {
66146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66147     return 0;
66148   }
66149   {
66150     try {
66151       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66152     } catch (std::out_of_range& e) {
66153       {
66154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66155       };
66156     } catch (std::exception& e) {
66157       {
66158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66159       };
66160     } catch (...) {
66161       {
66162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66163       };
66164     }
66165   }
66166   jresult = (void *)result;
66167   return jresult;
66168 }
66169
66170
66171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66172   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66173
66174   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66175   {
66176     try {
66177       delete arg1;
66178     } catch (std::out_of_range& e) {
66179       {
66180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66181       };
66182     } catch (std::exception& e) {
66183       {
66184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66185       };
66186     } catch (...) {
66187       {
66188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66189       };
66190     }
66191   }
66192 }
66193
66194
66195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66196   void * jresult ;
66197   Dali::Toolkit::PushButton result;
66198
66199   {
66200     try {
66201       result = Dali::Toolkit::PushButton::New();
66202     } catch (std::out_of_range& e) {
66203       {
66204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66205       };
66206     } catch (std::exception& e) {
66207       {
66208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66209       };
66210     } catch (...) {
66211       {
66212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66213       };
66214     }
66215   }
66216   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66217   return jresult;
66218 }
66219
66220
66221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66222   void * jresult ;
66223   Dali::BaseHandle arg1 ;
66224   Dali::BaseHandle *argp1 ;
66225   Dali::Toolkit::PushButton result;
66226
66227   argp1 = (Dali::BaseHandle *)jarg1;
66228   if (!argp1) {
66229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66230     return 0;
66231   }
66232   arg1 = *argp1;
66233   {
66234     try {
66235       result = Dali::Toolkit::PushButton::DownCast(arg1);
66236     } catch (std::out_of_range& e) {
66237       {
66238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66239       };
66240     } catch (std::exception& e) {
66241       {
66242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66243       };
66244     } catch (...) {
66245       {
66246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66247       };
66248     }
66249   }
66250   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66251   return jresult;
66252 }
66253
66254
66255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66256   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66257   Dali::Image arg2 ;
66258   Dali::Image *argp2 ;
66259
66260   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66261   argp2 = (Dali::Image *)jarg2;
66262   if (!argp2) {
66263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66264     return ;
66265   }
66266   arg2 = *argp2;
66267   {
66268     try {
66269       (arg1)->SetButtonImage(arg2);
66270     } catch (std::out_of_range& e) {
66271       {
66272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66273       };
66274     } catch (std::exception& e) {
66275       {
66276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66277       };
66278     } catch (...) {
66279       {
66280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66281       };
66282     }
66283   }
66284 }
66285
66286
66287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66288   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66289   Dali::Actor arg2 ;
66290   Dali::Actor *argp2 ;
66291
66292   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66293   argp2 = (Dali::Actor *)jarg2;
66294   if (!argp2) {
66295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66296     return ;
66297   }
66298   arg2 = *argp2;
66299   {
66300     try {
66301       (arg1)->SetButtonImage(arg2);
66302     } catch (std::out_of_range& e) {
66303       {
66304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66305       };
66306     } catch (std::exception& e) {
66307       {
66308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66313       };
66314     }
66315   }
66316 }
66317
66318
66319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66320   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66321   Dali::Actor arg2 ;
66322   Dali::Actor *argp2 ;
66323
66324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66325   argp2 = (Dali::Actor *)jarg2;
66326   if (!argp2) {
66327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66328     return ;
66329   }
66330   arg2 = *argp2;
66331   {
66332     try {
66333       (arg1)->SetBackgroundImage(arg2);
66334     } catch (std::out_of_range& e) {
66335       {
66336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66337       };
66338     } catch (std::exception& e) {
66339       {
66340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66341       };
66342     } catch (...) {
66343       {
66344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66345       };
66346     }
66347   }
66348 }
66349
66350
66351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66352   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66353   Dali::Image arg2 ;
66354   Dali::Image *argp2 ;
66355
66356   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66357   argp2 = (Dali::Image *)jarg2;
66358   if (!argp2) {
66359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66360     return ;
66361   }
66362   arg2 = *argp2;
66363   {
66364     try {
66365       (arg1)->SetSelectedImage(arg2);
66366     } catch (std::out_of_range& e) {
66367       {
66368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66369       };
66370     } catch (std::exception& e) {
66371       {
66372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66373       };
66374     } catch (...) {
66375       {
66376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66377       };
66378     }
66379   }
66380 }
66381
66382
66383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66384   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66385   Dali::Actor arg2 ;
66386   Dali::Actor *argp2 ;
66387
66388   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66389   argp2 = (Dali::Actor *)jarg2;
66390   if (!argp2) {
66391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66392     return ;
66393   }
66394   arg2 = *argp2;
66395   {
66396     try {
66397       (arg1)->SetSelectedImage(arg2);
66398     } catch (std::out_of_range& e) {
66399       {
66400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66401       };
66402     } catch (std::exception& e) {
66403       {
66404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66405       };
66406     } catch (...) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66409       };
66410     }
66411   }
66412 }
66413
66414
66415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66416   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66417   Dali::Actor arg2 ;
66418   Dali::Actor *argp2 ;
66419
66420   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66421   argp2 = (Dali::Actor *)jarg2;
66422   if (!argp2) {
66423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66424     return ;
66425   }
66426   arg2 = *argp2;
66427   {
66428     try {
66429       (arg1)->SetSelectedBackgroundImage(arg2);
66430     } catch (std::out_of_range& e) {
66431       {
66432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66433       };
66434     } catch (std::exception& e) {
66435       {
66436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66437       };
66438     } catch (...) {
66439       {
66440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66441       };
66442     }
66443   }
66444 }
66445
66446
66447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66448   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66449   Dali::Actor arg2 ;
66450   Dali::Actor *argp2 ;
66451
66452   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66453   argp2 = (Dali::Actor *)jarg2;
66454   if (!argp2) {
66455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66456     return ;
66457   }
66458   arg2 = *argp2;
66459   {
66460     try {
66461       (arg1)->SetDisabledBackgroundImage(arg2);
66462     } catch (std::out_of_range& e) {
66463       {
66464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66465       };
66466     } catch (std::exception& e) {
66467       {
66468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66469       };
66470     } catch (...) {
66471       {
66472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66473       };
66474     }
66475   }
66476 }
66477
66478
66479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66480   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66481   Dali::Actor arg2 ;
66482   Dali::Actor *argp2 ;
66483
66484   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66485   argp2 = (Dali::Actor *)jarg2;
66486   if (!argp2) {
66487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66488     return ;
66489   }
66490   arg2 = *argp2;
66491   {
66492     try {
66493       (arg1)->SetDisabledImage(arg2);
66494     } catch (std::out_of_range& e) {
66495       {
66496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66497       };
66498     } catch (std::exception& e) {
66499       {
66500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66501       };
66502     } catch (...) {
66503       {
66504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66505       };
66506     }
66507   }
66508 }
66509
66510
66511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66512   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66513   Dali::Actor arg2 ;
66514   Dali::Actor *argp2 ;
66515
66516   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66517   argp2 = (Dali::Actor *)jarg2;
66518   if (!argp2) {
66519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66520     return ;
66521   }
66522   arg2 = *argp2;
66523   {
66524     try {
66525       (arg1)->SetDisabledSelectedImage(arg2);
66526     } catch (std::out_of_range& e) {
66527       {
66528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66529       };
66530     } catch (std::exception& e) {
66531       {
66532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (...) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66537       };
66538     }
66539   }
66540 }
66541
66542
66543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66544   void * jresult ;
66545   Dali::Toolkit::RadioButton *result = 0 ;
66546
66547   {
66548     try {
66549       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66550     } catch (std::out_of_range& e) {
66551       {
66552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66553       };
66554     } catch (std::exception& e) {
66555       {
66556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66557       };
66558     } catch (...) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66561       };
66562     }
66563   }
66564   jresult = (void *)result;
66565   return jresult;
66566 }
66567
66568
66569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66570   void * jresult ;
66571   Dali::Toolkit::RadioButton *arg1 = 0 ;
66572   Dali::Toolkit::RadioButton *result = 0 ;
66573
66574   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66575   if (!arg1) {
66576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66577     return 0;
66578   }
66579   {
66580     try {
66581       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66582     } catch (std::out_of_range& e) {
66583       {
66584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66585       };
66586     } catch (std::exception& e) {
66587       {
66588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66589       };
66590     } catch (...) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66593       };
66594     }
66595   }
66596   jresult = (void *)result;
66597   return jresult;
66598 }
66599
66600
66601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66602   void * jresult ;
66603   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66604   Dali::Toolkit::RadioButton *arg2 = 0 ;
66605   Dali::Toolkit::RadioButton *result = 0 ;
66606
66607   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66608   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66609   if (!arg2) {
66610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66611     return 0;
66612   }
66613   {
66614     try {
66615       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66616     } catch (std::out_of_range& e) {
66617       {
66618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66619       };
66620     } catch (std::exception& e) {
66621       {
66622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66623       };
66624     } catch (...) {
66625       {
66626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66627       };
66628     }
66629   }
66630   jresult = (void *)result;
66631   return jresult;
66632 }
66633
66634
66635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66636   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66637
66638   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66639   {
66640     try {
66641       delete arg1;
66642     } catch (std::out_of_range& e) {
66643       {
66644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66645       };
66646     } catch (std::exception& e) {
66647       {
66648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66649       };
66650     } catch (...) {
66651       {
66652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66653       };
66654     }
66655   }
66656 }
66657
66658
66659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66660   void * jresult ;
66661   Dali::Toolkit::RadioButton result;
66662
66663   {
66664     try {
66665       result = Dali::Toolkit::RadioButton::New();
66666     } catch (std::out_of_range& e) {
66667       {
66668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66669       };
66670     } catch (std::exception& e) {
66671       {
66672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66673       };
66674     } catch (...) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66677       };
66678     }
66679   }
66680   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66681   return jresult;
66682 }
66683
66684
66685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66686   void * jresult ;
66687   std::string *arg1 = 0 ;
66688   Dali::Toolkit::RadioButton result;
66689
66690   if (!jarg1) {
66691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66692     return 0;
66693   }
66694   std::string arg1_str(jarg1);
66695   arg1 = &arg1_str;
66696   {
66697     try {
66698       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66699     } catch (std::out_of_range& e) {
66700       {
66701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66702       };
66703     } catch (std::exception& e) {
66704       {
66705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66706       };
66707     } catch (...) {
66708       {
66709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66710       };
66711     }
66712   }
66713   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66714
66715   //argout typemap for const std::string&
66716
66717   return jresult;
66718 }
66719
66720
66721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66722   void * jresult ;
66723   Dali::BaseHandle arg1 ;
66724   Dali::BaseHandle *argp1 ;
66725   Dali::Toolkit::RadioButton result;
66726
66727   argp1 = (Dali::BaseHandle *)jarg1;
66728   if (!argp1) {
66729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66730     return 0;
66731   }
66732   arg1 = *argp1;
66733   {
66734     try {
66735       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66736     } catch (std::out_of_range& e) {
66737       {
66738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66739       };
66740     } catch (std::exception& e) {
66741       {
66742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66743       };
66744     } catch (...) {
66745       {
66746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66747       };
66748     }
66749   }
66750   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66751   return jresult;
66752 }
66753
66754
66755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66756   int jresult ;
66757   int result;
66758
66759   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66760   jresult = (int)result;
66761   return jresult;
66762 }
66763
66764
66765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66766   int jresult ;
66767   int result;
66768
66769   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66770   jresult = (int)result;
66771   return jresult;
66772 }
66773
66774
66775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66776   int jresult ;
66777   int result;
66778
66779   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66780   jresult = (int)result;
66781   return jresult;
66782 }
66783
66784
66785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66786   int jresult ;
66787   int result;
66788
66789   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66790   jresult = (int)result;
66791   return jresult;
66792 }
66793
66794
66795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66796   int jresult ;
66797   int result;
66798
66799   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66800   jresult = (int)result;
66801   return jresult;
66802 }
66803
66804
66805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66806   int jresult ;
66807   int result;
66808
66809   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66810   jresult = (int)result;
66811   return jresult;
66812 }
66813
66814
66815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66816   void * jresult ;
66817   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66818
66819   {
66820     try {
66821       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66822     } catch (std::out_of_range& e) {
66823       {
66824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66825       };
66826     } catch (std::exception& e) {
66827       {
66828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66833       };
66834     }
66835   }
66836   jresult = (void *)result;
66837   return jresult;
66838 }
66839
66840
66841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66842   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66843
66844   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66845   {
66846     try {
66847       delete arg1;
66848     } catch (std::out_of_range& e) {
66849       {
66850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66851       };
66852     } catch (std::exception& e) {
66853       {
66854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66855       };
66856     } catch (...) {
66857       {
66858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66859       };
66860     }
66861   }
66862 }
66863
66864
66865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66866   int jresult ;
66867   int result;
66868
66869   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66870   jresult = (int)result;
66871   return jresult;
66872 }
66873
66874
66875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66876   int jresult ;
66877   int result;
66878
66879   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66880   jresult = (int)result;
66881   return jresult;
66882 }
66883
66884
66885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66886   int jresult ;
66887   int result;
66888
66889   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66890   jresult = (int)result;
66891   return jresult;
66892 }
66893
66894
66895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66896   void * jresult ;
66897   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66898
66899   {
66900     try {
66901       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66902     } catch (std::out_of_range& e) {
66903       {
66904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66905       };
66906     } catch (std::exception& e) {
66907       {
66908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66909       };
66910     } catch (...) {
66911       {
66912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66913       };
66914     }
66915   }
66916   jresult = (void *)result;
66917   return jresult;
66918 }
66919
66920
66921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66922   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66923
66924   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66925   {
66926     try {
66927       delete arg1;
66928     } catch (std::out_of_range& e) {
66929       {
66930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66931       };
66932     } catch (std::exception& e) {
66933       {
66934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66935       };
66936     } catch (...) {
66937       {
66938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66939       };
66940     }
66941   }
66942 }
66943
66944
66945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66946   void * jresult ;
66947   Dali::Toolkit::FlexContainer *result = 0 ;
66948
66949   {
66950     try {
66951       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66952     } catch (std::out_of_range& e) {
66953       {
66954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66955       };
66956     } catch (std::exception& e) {
66957       {
66958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66959       };
66960     } catch (...) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66963       };
66964     }
66965   }
66966   jresult = (void *)result;
66967   return jresult;
66968 }
66969
66970
66971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66972   void * jresult ;
66973   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66974   Dali::Toolkit::FlexContainer *result = 0 ;
66975
66976   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66977   if (!arg1) {
66978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66979     return 0;
66980   }
66981   {
66982     try {
66983       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66991       };
66992     } catch (...) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66995       };
66996     }
66997   }
66998   jresult = (void *)result;
66999   return jresult;
67000 }
67001
67002
67003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
67004   void * jresult ;
67005   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67006   Dali::Toolkit::FlexContainer *arg2 = 0 ;
67007   Dali::Toolkit::FlexContainer *result = 0 ;
67008
67009   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67010   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
67011   if (!arg2) {
67012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67013     return 0;
67014   }
67015   {
67016     try {
67017       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
67018     } catch (std::out_of_range& e) {
67019       {
67020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (std::exception& e) {
67023       {
67024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67025       };
67026     } catch (...) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67029       };
67030     }
67031   }
67032   jresult = (void *)result;
67033   return jresult;
67034 }
67035
67036
67037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67038   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67039
67040   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67041   {
67042     try {
67043       delete arg1;
67044     } catch (std::out_of_range& e) {
67045       {
67046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67047       };
67048     } catch (std::exception& e) {
67049       {
67050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67051       };
67052     } catch (...) {
67053       {
67054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67055       };
67056     }
67057   }
67058 }
67059
67060
67061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67062   void * jresult ;
67063   Dali::Toolkit::FlexContainer result;
67064
67065   {
67066     try {
67067       result = Dali::Toolkit::FlexContainer::New();
67068     } catch (std::out_of_range& e) {
67069       {
67070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67071       };
67072     } catch (std::exception& e) {
67073       {
67074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67075       };
67076     } catch (...) {
67077       {
67078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67079       };
67080     }
67081   }
67082   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67083   return jresult;
67084 }
67085
67086
67087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67088   void * jresult ;
67089   Dali::BaseHandle arg1 ;
67090   Dali::BaseHandle *argp1 ;
67091   Dali::Toolkit::FlexContainer result;
67092
67093   argp1 = (Dali::BaseHandle *)jarg1;
67094   if (!argp1) {
67095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67096     return 0;
67097   }
67098   arg1 = *argp1;
67099   {
67100     try {
67101       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67102     } catch (std::out_of_range& e) {
67103       {
67104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67105       };
67106     } catch (std::exception& e) {
67107       {
67108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67109       };
67110     } catch (...) {
67111       {
67112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67113       };
67114     }
67115   }
67116   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67117   return jresult;
67118 }
67119
67120
67121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67122   int jresult ;
67123   int result;
67124
67125   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67126   jresult = (int)result;
67127   return jresult;
67128 }
67129
67130
67131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67132   int jresult ;
67133   int result;
67134
67135   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67136   jresult = (int)result;
67137   return jresult;
67138 }
67139
67140
67141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67142   int jresult ;
67143   int result;
67144
67145   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67146   jresult = (int)result;
67147   return jresult;
67148 }
67149
67150
67151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67152   int jresult ;
67153   int result;
67154
67155   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67156   jresult = (int)result;
67157   return jresult;
67158 }
67159
67160
67161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67162   void * jresult ;
67163   Dali::Toolkit::ImageView::Property *result = 0 ;
67164
67165   {
67166     try {
67167       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67168     } catch (std::out_of_range& e) {
67169       {
67170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67171       };
67172     } catch (std::exception& e) {
67173       {
67174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67175       };
67176     } catch (...) {
67177       {
67178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67179       };
67180     }
67181   }
67182   jresult = (void *)result;
67183   return jresult;
67184 }
67185
67186
67187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67188   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67189
67190   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67191   {
67192     try {
67193       delete arg1;
67194     } catch (std::out_of_range& e) {
67195       {
67196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67197       };
67198     } catch (std::exception& e) {
67199       {
67200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67201       };
67202     } catch (...) {
67203       {
67204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67205       };
67206     }
67207   }
67208 }
67209
67210
67211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67212   void * jresult ;
67213   Dali::Toolkit::ImageView *result = 0 ;
67214
67215   {
67216     try {
67217       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67218     } catch (std::out_of_range& e) {
67219       {
67220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67221       };
67222     } catch (std::exception& e) {
67223       {
67224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67225       };
67226     } catch (...) {
67227       {
67228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67229       };
67230     }
67231   }
67232   jresult = (void *)result;
67233   return jresult;
67234 }
67235
67236
67237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67238   void * jresult ;
67239   Dali::Toolkit::ImageView result;
67240
67241   {
67242     try {
67243       result = Dali::Toolkit::ImageView::New();
67244     } catch (std::out_of_range& e) {
67245       {
67246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67247       };
67248     } catch (std::exception& e) {
67249       {
67250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67251       };
67252     } catch (...) {
67253       {
67254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67255       };
67256     }
67257   }
67258   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67259   return jresult;
67260 }
67261
67262
67263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67264   void * jresult ;
67265   Dali::Image arg1 ;
67266   Dali::Image *argp1 ;
67267   Dali::Toolkit::ImageView result;
67268
67269   argp1 = (Dali::Image *)jarg1;
67270   if (!argp1) {
67271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67272     return 0;
67273   }
67274   arg1 = *argp1;
67275   {
67276     try {
67277       result = Dali::Toolkit::ImageView::New(arg1);
67278     } catch (std::out_of_range& e) {
67279       {
67280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (std::exception& e) {
67283       {
67284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67285       };
67286     } catch (...) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67289       };
67290     }
67291   }
67292   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67293   return jresult;
67294 }
67295
67296
67297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67298   void * jresult ;
67299   std::string *arg1 = 0 ;
67300   Dali::Toolkit::ImageView result;
67301
67302   if (!jarg1) {
67303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67304     return 0;
67305   }
67306   std::string arg1_str(jarg1);
67307   arg1 = &arg1_str;
67308   {
67309     try {
67310       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67311     } catch (std::out_of_range& e) {
67312       {
67313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67314       };
67315     } catch (std::exception& e) {
67316       {
67317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67318       };
67319     } catch (...) {
67320       {
67321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67322       };
67323     }
67324   }
67325   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67326
67327   //argout typemap for const std::string&
67328
67329   return jresult;
67330 }
67331
67332
67333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67334   void * jresult ;
67335   std::string *arg1 = 0 ;
67336   Dali::ImageDimensions arg2 ;
67337   Dali::ImageDimensions *argp2 ;
67338   Dali::Toolkit::ImageView result;
67339
67340   if (!jarg1) {
67341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67342     return 0;
67343   }
67344   std::string arg1_str(jarg1);
67345   arg1 = &arg1_str;
67346   argp2 = (Dali::ImageDimensions *)jarg2;
67347   if (!argp2) {
67348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67349     return 0;
67350   }
67351   arg2 = *argp2;
67352   {
67353     try {
67354       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67355     } catch (std::out_of_range& e) {
67356       {
67357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67358       };
67359     } catch (std::exception& e) {
67360       {
67361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67362       };
67363     } catch (...) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67366       };
67367     }
67368   }
67369   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67370
67371   //argout typemap for const std::string&
67372
67373   return jresult;
67374 }
67375
67376
67377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67378   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67379
67380   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67381   {
67382     try {
67383       delete arg1;
67384     } catch (std::out_of_range& e) {
67385       {
67386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67387       };
67388     } catch (std::exception& e) {
67389       {
67390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (...) {
67393       {
67394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67395       };
67396     }
67397   }
67398 }
67399
67400
67401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67402   void * jresult ;
67403   Dali::Toolkit::ImageView *arg1 = 0 ;
67404   Dali::Toolkit::ImageView *result = 0 ;
67405
67406   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67407   if (!arg1) {
67408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67409     return 0;
67410   }
67411   {
67412     try {
67413       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67414     } catch (std::out_of_range& e) {
67415       {
67416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67417       };
67418     } catch (std::exception& e) {
67419       {
67420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67421       };
67422     } catch (...) {
67423       {
67424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67425       };
67426     }
67427   }
67428   jresult = (void *)result;
67429   return jresult;
67430 }
67431
67432
67433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67434   void * jresult ;
67435   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67436   Dali::Toolkit::ImageView *arg2 = 0 ;
67437   Dali::Toolkit::ImageView *result = 0 ;
67438
67439   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67440   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67441   if (!arg2) {
67442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67443     return 0;
67444   }
67445   {
67446     try {
67447       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67448     } catch (std::out_of_range& e) {
67449       {
67450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67451       };
67452     } catch (std::exception& e) {
67453       {
67454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67455       };
67456     } catch (...) {
67457       {
67458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67459       };
67460     }
67461   }
67462   jresult = (void *)result;
67463   return jresult;
67464 }
67465
67466
67467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67468   void * jresult ;
67469   Dali::BaseHandle arg1 ;
67470   Dali::BaseHandle *argp1 ;
67471   Dali::Toolkit::ImageView result;
67472
67473   argp1 = (Dali::BaseHandle *)jarg1;
67474   if (!argp1) {
67475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67476     return 0;
67477   }
67478   arg1 = *argp1;
67479   {
67480     try {
67481       result = Dali::Toolkit::ImageView::DownCast(arg1);
67482     } catch (std::out_of_range& e) {
67483       {
67484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67485       };
67486     } catch (std::exception& e) {
67487       {
67488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67489       };
67490     } catch (...) {
67491       {
67492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67493       };
67494     }
67495   }
67496   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67497   return jresult;
67498 }
67499
67500
67501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67502   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67503   Dali::Image arg2 ;
67504   Dali::Image *argp2 ;
67505
67506   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67507   argp2 = (Dali::Image *)jarg2;
67508   if (!argp2) {
67509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67510     return ;
67511   }
67512   arg2 = *argp2;
67513   {
67514     try {
67515       (arg1)->SetImage(arg2);
67516     } catch (std::out_of_range& e) {
67517       {
67518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67519       };
67520     } catch (std::exception& e) {
67521       {
67522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67523       };
67524     } catch (...) {
67525       {
67526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67527       };
67528     }
67529   }
67530 }
67531
67532
67533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67534   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67535   std::string *arg2 = 0 ;
67536
67537   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67538   if (!jarg2) {
67539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67540     return ;
67541   }
67542   std::string arg2_str(jarg2);
67543   arg2 = &arg2_str;
67544   {
67545     try {
67546       (arg1)->SetImage((std::string const &)*arg2);
67547     } catch (std::out_of_range& e) {
67548       {
67549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67550       };
67551     } catch (std::exception& e) {
67552       {
67553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67554       };
67555     } catch (...) {
67556       {
67557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67558       };
67559     }
67560   }
67561
67562   //argout typemap for const std::string&
67563
67564 }
67565
67566
67567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67568   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67569   std::string *arg2 = 0 ;
67570   Dali::ImageDimensions arg3 ;
67571   Dali::ImageDimensions *argp3 ;
67572
67573   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67574   if (!jarg2) {
67575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67576     return ;
67577   }
67578   std::string arg2_str(jarg2);
67579   arg2 = &arg2_str;
67580   argp3 = (Dali::ImageDimensions *)jarg3;
67581   if (!argp3) {
67582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67583     return ;
67584   }
67585   arg3 = *argp3;
67586   {
67587     try {
67588       (arg1)->SetImage((std::string const &)*arg2,arg3);
67589     } catch (std::out_of_range& e) {
67590       {
67591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67592       };
67593     } catch (std::exception& e) {
67594       {
67595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67596       };
67597     } catch (...) {
67598       {
67599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67600       };
67601     }
67602   }
67603
67604   //argout typemap for const std::string&
67605
67606 }
67607
67608
67609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67610   void * jresult ;
67611   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67612   Dali::Image result;
67613
67614   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67615   {
67616     try {
67617       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67625       };
67626     } catch (...) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67629       };
67630     }
67631   }
67632   jresult = new Dali::Image((const Dali::Image &)result);
67633   return jresult;
67634 }
67635
67636
67637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67638   int jresult ;
67639   int result;
67640
67641   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67642   jresult = (int)result;
67643   return jresult;
67644 }
67645
67646
67647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67648   int jresult ;
67649   int result;
67650
67651   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67652   jresult = (int)result;
67653   return jresult;
67654 }
67655
67656
67657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67658   int jresult ;
67659   int result;
67660
67661   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67662   jresult = (int)result;
67663   return jresult;
67664 }
67665
67666
67667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67668   int jresult ;
67669   int result;
67670
67671   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67672   jresult = (int)result;
67673   return jresult;
67674 }
67675
67676
67677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67678   int jresult ;
67679   int result;
67680
67681   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67682   jresult = (int)result;
67683   return jresult;
67684 }
67685
67686
67687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67688   int jresult ;
67689   int result;
67690
67691   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67692   jresult = (int)result;
67693   return jresult;
67694 }
67695
67696
67697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67698   int jresult ;
67699   int result;
67700
67701   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67702   jresult = (int)result;
67703   return jresult;
67704 }
67705
67706
67707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67708   int jresult ;
67709   int result;
67710
67711   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67712   jresult = (int)result;
67713   return jresult;
67714 }
67715
67716
67717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67718   void * jresult ;
67719   Dali::Toolkit::Model3dView::Property *result = 0 ;
67720
67721   {
67722     try {
67723       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67724     } catch (std::out_of_range& e) {
67725       {
67726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67727       };
67728     } catch (std::exception& e) {
67729       {
67730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67731       };
67732     } catch (...) {
67733       {
67734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67735       };
67736     }
67737   }
67738   jresult = (void *)result;
67739   return jresult;
67740 }
67741
67742
67743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67744   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67745
67746   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67747   {
67748     try {
67749       delete arg1;
67750     } catch (std::out_of_range& e) {
67751       {
67752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67753       };
67754     } catch (std::exception& e) {
67755       {
67756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67757       };
67758     } catch (...) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67761       };
67762     }
67763   }
67764 }
67765
67766
67767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67768   void * jresult ;
67769   Dali::Toolkit::Model3dView result;
67770
67771   {
67772     try {
67773       result = Dali::Toolkit::Model3dView::New();
67774     } catch (std::out_of_range& e) {
67775       {
67776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67777       };
67778     } catch (std::exception& e) {
67779       {
67780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67781       };
67782     } catch (...) {
67783       {
67784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67785       };
67786     }
67787   }
67788   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67789   return jresult;
67790 }
67791
67792
67793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67794   void * jresult ;
67795   std::string *arg1 = 0 ;
67796   std::string *arg2 = 0 ;
67797   std::string *arg3 = 0 ;
67798   Dali::Toolkit::Model3dView result;
67799
67800   if (!jarg1) {
67801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67802     return 0;
67803   }
67804   std::string arg1_str(jarg1);
67805   arg1 = &arg1_str;
67806   if (!jarg2) {
67807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67808     return 0;
67809   }
67810   std::string arg2_str(jarg2);
67811   arg2 = &arg2_str;
67812   if (!jarg3) {
67813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67814     return 0;
67815   }
67816   std::string arg3_str(jarg3);
67817   arg3 = &arg3_str;
67818   {
67819     try {
67820       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67821     } catch (std::out_of_range& e) {
67822       {
67823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67824       };
67825     } catch (std::exception& e) {
67826       {
67827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67828       };
67829     } catch (...) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67832       };
67833     }
67834   }
67835   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67836
67837   //argout typemap for const std::string&
67838
67839
67840   //argout typemap for const std::string&
67841
67842
67843   //argout typemap for const std::string&
67844
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67850   void * jresult ;
67851   Dali::Toolkit::Model3dView *result = 0 ;
67852
67853   {
67854     try {
67855       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67863       };
67864     } catch (...) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67867       };
67868     }
67869   }
67870   jresult = (void *)result;
67871   return jresult;
67872 }
67873
67874
67875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67876   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67877
67878   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67879   {
67880     try {
67881       delete arg1;
67882     } catch (std::out_of_range& e) {
67883       {
67884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67885       };
67886     } catch (std::exception& e) {
67887       {
67888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67889       };
67890     } catch (...) {
67891       {
67892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67893       };
67894     }
67895   }
67896 }
67897
67898
67899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67900   void * jresult ;
67901   Dali::Toolkit::Model3dView *arg1 = 0 ;
67902   Dali::Toolkit::Model3dView *result = 0 ;
67903
67904   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67905   if (!arg1) {
67906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67907     return 0;
67908   }
67909   {
67910     try {
67911       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67912     } catch (std::out_of_range& e) {
67913       {
67914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67915       };
67916     } catch (std::exception& e) {
67917       {
67918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (...) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67923       };
67924     }
67925   }
67926   jresult = (void *)result;
67927   return jresult;
67928 }
67929
67930
67931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67932   void * jresult ;
67933   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67934   Dali::Toolkit::Model3dView *arg2 = 0 ;
67935   Dali::Toolkit::Model3dView *result = 0 ;
67936
67937   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67938   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67939   if (!arg2) {
67940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67941     return 0;
67942   }
67943   {
67944     try {
67945       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67946     } catch (std::out_of_range& e) {
67947       {
67948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67949       };
67950     } catch (std::exception& e) {
67951       {
67952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67953       };
67954     } catch (...) {
67955       {
67956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67957       };
67958     }
67959   }
67960   jresult = (void *)result;
67961   return jresult;
67962 }
67963
67964
67965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67966   void * jresult ;
67967   Dali::BaseHandle arg1 ;
67968   Dali::BaseHandle *argp1 ;
67969   Dali::Toolkit::Model3dView result;
67970
67971   argp1 = (Dali::BaseHandle *)jarg1;
67972   if (!argp1) {
67973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67974     return 0;
67975   }
67976   arg1 = *argp1;
67977   {
67978     try {
67979       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67980     } catch (std::out_of_range& e) {
67981       {
67982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67983       };
67984     } catch (std::exception& e) {
67985       {
67986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67987       };
67988     } catch (...) {
67989       {
67990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67991       };
67992     }
67993   }
67994   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67995   return jresult;
67996 }
67997
67998
67999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
68000   int jresult ;
68001   int result;
68002
68003   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
68004   jresult = (int)result;
68005   return jresult;
68006 }
68007
68008
68009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
68010   int jresult ;
68011   int result;
68012
68013   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
68014   jresult = (int)result;
68015   return jresult;
68016 }
68017
68018
68019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
68020   int jresult ;
68021   int result;
68022
68023   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68024   jresult = (int)result;
68025   return jresult;
68026 }
68027
68028
68029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68030   int jresult ;
68031   int result;
68032
68033   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68034   jresult = (int)result;
68035   return jresult;
68036 }
68037
68038
68039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68040   int jresult ;
68041   int result;
68042
68043   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68044   jresult = (int)result;
68045   return jresult;
68046 }
68047
68048
68049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68050   int jresult ;
68051   int result;
68052
68053   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68054   jresult = (int)result;
68055   return jresult;
68056 }
68057
68058
68059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68060   int jresult ;
68061   int result;
68062
68063   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68064   jresult = (int)result;
68065   return jresult;
68066 }
68067
68068
68069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68070   int jresult ;
68071   int result;
68072
68073   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68074   jresult = (int)result;
68075   return jresult;
68076 }
68077
68078
68079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68080   int jresult ;
68081   int result;
68082
68083   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68084   jresult = (int)result;
68085   return jresult;
68086 }
68087
68088
68089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68090   void * jresult ;
68091   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68092
68093   {
68094     try {
68095       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68096     } catch (std::out_of_range& e) {
68097       {
68098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68099       };
68100     } catch (std::exception& e) {
68101       {
68102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (...) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68107       };
68108     }
68109   }
68110   jresult = (void *)result;
68111   return jresult;
68112 }
68113
68114
68115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68116   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68117
68118   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68119   {
68120     try {
68121       delete arg1;
68122     } catch (std::out_of_range& e) {
68123       {
68124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68125       };
68126     } catch (std::exception& e) {
68127       {
68128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68133       };
68134     }
68135   }
68136 }
68137
68138
68139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68140   void * jresult ;
68141   Dali::Toolkit::ScrollBar *result = 0 ;
68142
68143   {
68144     try {
68145       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68146     } catch (std::out_of_range& e) {
68147       {
68148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68149       };
68150     } catch (std::exception& e) {
68151       {
68152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68153       };
68154     } catch (...) {
68155       {
68156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68157       };
68158     }
68159   }
68160   jresult = (void *)result;
68161   return jresult;
68162 }
68163
68164
68165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68166   void * jresult ;
68167   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68168   Dali::Toolkit::ScrollBar *result = 0 ;
68169
68170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68171   if (!arg1) {
68172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68173     return 0;
68174   }
68175   {
68176     try {
68177       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68178     } catch (std::out_of_range& e) {
68179       {
68180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68181       };
68182     } catch (std::exception& e) {
68183       {
68184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68185       };
68186     } catch (...) {
68187       {
68188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68189       };
68190     }
68191   }
68192   jresult = (void *)result;
68193   return jresult;
68194 }
68195
68196
68197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68198   void * jresult ;
68199   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68200   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68201   Dali::Toolkit::ScrollBar *result = 0 ;
68202
68203   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68204   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68205   if (!arg2) {
68206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68207     return 0;
68208   }
68209   {
68210     try {
68211       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68212     } catch (std::out_of_range& e) {
68213       {
68214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68215       };
68216     } catch (std::exception& e) {
68217       {
68218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68223       };
68224     }
68225   }
68226   jresult = (void *)result;
68227   return jresult;
68228 }
68229
68230
68231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68232   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68233
68234   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68235   {
68236     try {
68237       delete arg1;
68238     } catch (std::out_of_range& e) {
68239       {
68240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68241       };
68242     } catch (std::exception& e) {
68243       {
68244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68245       };
68246     } catch (...) {
68247       {
68248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68249       };
68250     }
68251   }
68252 }
68253
68254
68255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68256   void * jresult ;
68257   Dali::Toolkit::ScrollBar::Direction arg1 ;
68258   Dali::Toolkit::ScrollBar result;
68259
68260   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68261   {
68262     try {
68263       result = Dali::Toolkit::ScrollBar::New(arg1);
68264     } catch (std::out_of_range& e) {
68265       {
68266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68267       };
68268     } catch (std::exception& e) {
68269       {
68270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68271       };
68272     } catch (...) {
68273       {
68274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68275       };
68276     }
68277   }
68278   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68279   return jresult;
68280 }
68281
68282
68283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68284   void * jresult ;
68285   Dali::Toolkit::ScrollBar result;
68286
68287   {
68288     try {
68289       result = Dali::Toolkit::ScrollBar::New();
68290     } catch (std::out_of_range& e) {
68291       {
68292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68293       };
68294     } catch (std::exception& e) {
68295       {
68296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68297       };
68298     } catch (...) {
68299       {
68300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68301       };
68302     }
68303   }
68304   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68305   return jresult;
68306 }
68307
68308
68309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68310   void * jresult ;
68311   Dali::BaseHandle arg1 ;
68312   Dali::BaseHandle *argp1 ;
68313   Dali::Toolkit::ScrollBar result;
68314
68315   argp1 = (Dali::BaseHandle *)jarg1;
68316   if (!argp1) {
68317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68318     return 0;
68319   }
68320   arg1 = *argp1;
68321   {
68322     try {
68323       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68324     } catch (std::out_of_range& e) {
68325       {
68326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (std::exception& e) {
68329       {
68330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68331       };
68332     } catch (...) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68335       };
68336     }
68337   }
68338   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68339   return jresult;
68340 }
68341
68342
68343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68344   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68345   Dali::Handle arg2 ;
68346   Dali::Property::Index arg3 ;
68347   Dali::Property::Index arg4 ;
68348   Dali::Property::Index arg5 ;
68349   Dali::Property::Index arg6 ;
68350   Dali::Handle *argp2 ;
68351
68352   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68353   argp2 = (Dali::Handle *)jarg2;
68354   if (!argp2) {
68355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68356     return ;
68357   }
68358   arg2 = *argp2;
68359   arg3 = (Dali::Property::Index)jarg3;
68360   arg4 = (Dali::Property::Index)jarg4;
68361   arg5 = (Dali::Property::Index)jarg5;
68362   arg6 = (Dali::Property::Index)jarg6;
68363   {
68364     try {
68365       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68366     } catch (std::out_of_range& e) {
68367       {
68368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68369       };
68370     } catch (std::exception& e) {
68371       {
68372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68373       };
68374     } catch (...) {
68375       {
68376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68377       };
68378     }
68379   }
68380 }
68381
68382
68383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68384   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68385   Dali::Actor arg2 ;
68386   Dali::Actor *argp2 ;
68387
68388   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68389   argp2 = (Dali::Actor *)jarg2;
68390   if (!argp2) {
68391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68392     return ;
68393   }
68394   arg2 = *argp2;
68395   {
68396     try {
68397       (arg1)->SetScrollIndicator(arg2);
68398     } catch (std::out_of_range& e) {
68399       {
68400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68401       };
68402     } catch (std::exception& e) {
68403       {
68404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68405       };
68406     } catch (...) {
68407       {
68408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68409       };
68410     }
68411   }
68412 }
68413
68414
68415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68416   void * jresult ;
68417   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68418   Dali::Actor result;
68419
68420   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68421   {
68422     try {
68423       result = (arg1)->GetScrollIndicator();
68424     } catch (std::out_of_range& e) {
68425       {
68426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68427       };
68428     } catch (std::exception& e) {
68429       {
68430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68431       };
68432     } catch (...) {
68433       {
68434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68435       };
68436     }
68437   }
68438   jresult = new Dali::Actor((const Dali::Actor &)result);
68439   return jresult;
68440 }
68441
68442
68443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68444   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68445   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68446
68447   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68448   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68449   if (!arg2) {
68450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68451     return ;
68452   }
68453   {
68454     try {
68455       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68456     } catch (std::out_of_range& e) {
68457       {
68458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68459       };
68460     } catch (std::exception& e) {
68461       {
68462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68463       };
68464     } catch (...) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68467       };
68468     }
68469   }
68470 }
68471
68472
68473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68474   void * jresult ;
68475   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68476   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68477
68478   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68479   {
68480     try {
68481       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68482     } catch (std::out_of_range& e) {
68483       {
68484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68485       };
68486     } catch (std::exception& e) {
68487       {
68488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68489       };
68490     } catch (...) {
68491       {
68492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68493       };
68494     }
68495   }
68496   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68497   return jresult;
68498 }
68499
68500
68501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68502   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68503   Dali::Toolkit::ScrollBar::Direction arg2 ;
68504
68505   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68506   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68507   {
68508     try {
68509       (arg1)->SetScrollDirection(arg2);
68510     } catch (std::out_of_range& e) {
68511       {
68512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68513       };
68514     } catch (std::exception& e) {
68515       {
68516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68517       };
68518     } catch (...) {
68519       {
68520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68521       };
68522     }
68523   }
68524 }
68525
68526
68527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68528   int jresult ;
68529   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68530   Dali::Toolkit::ScrollBar::Direction result;
68531
68532   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68533   {
68534     try {
68535       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68536     } catch (std::out_of_range& e) {
68537       {
68538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68539       };
68540     } catch (std::exception& e) {
68541       {
68542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68543       };
68544     } catch (...) {
68545       {
68546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68547       };
68548     }
68549   }
68550   jresult = (int)result;
68551   return jresult;
68552 }
68553
68554
68555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68556   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68557   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68558
68559   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68560   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68561   {
68562     try {
68563       (arg1)->SetIndicatorHeightPolicy(arg2);
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68575       };
68576     }
68577   }
68578 }
68579
68580
68581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68582   int jresult ;
68583   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68584   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68585
68586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68587   {
68588     try {
68589       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68590     } catch (std::out_of_range& e) {
68591       {
68592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68593       };
68594     } catch (std::exception& e) {
68595       {
68596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68601       };
68602     }
68603   }
68604   jresult = (int)result;
68605   return jresult;
68606 }
68607
68608
68609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68610   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68611   float arg2 ;
68612
68613   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68614   arg2 = (float)jarg2;
68615   {
68616     try {
68617       (arg1)->SetIndicatorFixedHeight(arg2);
68618     } catch (std::out_of_range& e) {
68619       {
68620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68621       };
68622     } catch (std::exception& e) {
68623       {
68624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68625       };
68626     } catch (...) {
68627       {
68628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68629       };
68630     }
68631   }
68632 }
68633
68634
68635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68636   float jresult ;
68637   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68638   float result;
68639
68640   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68641   {
68642     try {
68643       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68644     } catch (std::out_of_range& e) {
68645       {
68646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68647       };
68648     } catch (std::exception& e) {
68649       {
68650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68651       };
68652     } catch (...) {
68653       {
68654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68655       };
68656     }
68657   }
68658   jresult = result;
68659   return jresult;
68660 }
68661
68662
68663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68664   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68665   float arg2 ;
68666
68667   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68668   arg2 = (float)jarg2;
68669   {
68670     try {
68671       (arg1)->SetIndicatorShowDuration(arg2);
68672     } catch (std::out_of_range& e) {
68673       {
68674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68675       };
68676     } catch (std::exception& e) {
68677       {
68678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68679       };
68680     } catch (...) {
68681       {
68682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68683       };
68684     }
68685   }
68686 }
68687
68688
68689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68690   float jresult ;
68691   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68692   float result;
68693
68694   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68695   {
68696     try {
68697       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68698     } catch (std::out_of_range& e) {
68699       {
68700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68701       };
68702     } catch (std::exception& e) {
68703       {
68704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68705       };
68706     } catch (...) {
68707       {
68708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68709       };
68710     }
68711   }
68712   jresult = result;
68713   return jresult;
68714 }
68715
68716
68717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68718   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68719   float arg2 ;
68720
68721   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68722   arg2 = (float)jarg2;
68723   {
68724     try {
68725       (arg1)->SetIndicatorHideDuration(arg2);
68726     } catch (std::out_of_range& e) {
68727       {
68728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68729       };
68730     } catch (std::exception& e) {
68731       {
68732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68733       };
68734     } catch (...) {
68735       {
68736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68737       };
68738     }
68739   }
68740 }
68741
68742
68743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68744   float jresult ;
68745   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68746   float result;
68747
68748   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68749   {
68750     try {
68751       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68752     } catch (std::out_of_range& e) {
68753       {
68754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68755       };
68756     } catch (std::exception& e) {
68757       {
68758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68759       };
68760     } catch (...) {
68761       {
68762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68763       };
68764     }
68765   }
68766   jresult = result;
68767   return jresult;
68768 }
68769
68770
68771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68772   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68773
68774   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68775   {
68776     try {
68777       (arg1)->ShowIndicator();
68778     } catch (std::out_of_range& e) {
68779       {
68780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68781       };
68782     } catch (std::exception& e) {
68783       {
68784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68785       };
68786     } catch (...) {
68787       {
68788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68789       };
68790     }
68791   }
68792 }
68793
68794
68795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68796   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68797
68798   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68799   {
68800     try {
68801       (arg1)->HideIndicator();
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68809       };
68810     } catch (...) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68813       };
68814     }
68815   }
68816 }
68817
68818
68819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68820   void * jresult ;
68821   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68822   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68823
68824   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68825   {
68826     try {
68827       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68828     } catch (std::out_of_range& e) {
68829       {
68830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68831       };
68832     } catch (std::exception& e) {
68833       {
68834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (...) {
68837       {
68838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68839       };
68840     }
68841   }
68842   jresult = (void *)result;
68843   return jresult;
68844 }
68845
68846
68847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68848   void * jresult ;
68849   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68850   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68851
68852   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68853   {
68854     try {
68855       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68856     } catch (std::out_of_range& e) {
68857       {
68858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68859       };
68860     } catch (std::exception& e) {
68861       {
68862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68863       };
68864     } catch (...) {
68865       {
68866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68867       };
68868     }
68869   }
68870   jresult = (void *)result;
68871   return jresult;
68872 }
68873
68874
68875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68876   int jresult ;
68877   int result;
68878
68879   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68880   jresult = (int)result;
68881   return jresult;
68882 }
68883
68884
68885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68886   int jresult ;
68887   int result;
68888
68889   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68890   jresult = (int)result;
68891   return jresult;
68892 }
68893
68894
68895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68896   int jresult ;
68897   int result;
68898
68899   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68900   jresult = (int)result;
68901   return jresult;
68902 }
68903
68904
68905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68906   int jresult ;
68907   int result;
68908
68909   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68910   jresult = (int)result;
68911   return jresult;
68912 }
68913
68914
68915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68916   int jresult ;
68917   int result;
68918
68919   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68920   jresult = (int)result;
68921   return jresult;
68922 }
68923
68924
68925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68926   int jresult ;
68927   int result;
68928
68929   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68930   jresult = (int)result;
68931   return jresult;
68932 }
68933
68934
68935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68936   int jresult ;
68937   int result;
68938
68939   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68940   jresult = (int)result;
68941   return jresult;
68942 }
68943
68944
68945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68946   int jresult ;
68947   int result;
68948
68949   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68950   jresult = (int)result;
68951   return jresult;
68952 }
68953
68954
68955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68956   int jresult ;
68957   int result;
68958
68959   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68960   jresult = (int)result;
68961   return jresult;
68962 }
68963
68964
68965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68966   int jresult ;
68967   int result;
68968
68969   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68970   jresult = (int)result;
68971   return jresult;
68972 }
68973
68974
68975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68976   int jresult ;
68977   int result;
68978
68979   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68980   jresult = (int)result;
68981   return jresult;
68982 }
68983
68984
68985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68986   int jresult ;
68987   int result;
68988
68989   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68990   jresult = (int)result;
68991   return jresult;
68992 }
68993
68994
68995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68996   int jresult ;
68997   int result;
68998
68999   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69000   jresult = (int)result;
69001   return jresult;
69002 }
69003
69004
69005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69006   int jresult ;
69007   int result;
69008
69009   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69010   jresult = (int)result;
69011   return jresult;
69012 }
69013
69014
69015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69016   void * jresult ;
69017   Dali::Toolkit::Scrollable::Property *result = 0 ;
69018
69019   {
69020     try {
69021       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69022     } catch (std::out_of_range& e) {
69023       {
69024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69025       };
69026     } catch (std::exception& e) {
69027       {
69028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69029       };
69030     } catch (...) {
69031       {
69032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69033       };
69034     }
69035   }
69036   jresult = (void *)result;
69037   return jresult;
69038 }
69039
69040
69041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
69042   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69043
69044   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
69045   {
69046     try {
69047       delete arg1;
69048     } catch (std::out_of_range& e) {
69049       {
69050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69051       };
69052     } catch (std::exception& e) {
69053       {
69054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69055       };
69056     } catch (...) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69059       };
69060     }
69061   }
69062 }
69063
69064
69065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
69066   void * jresult ;
69067   Dali::Toolkit::Scrollable *result = 0 ;
69068
69069   {
69070     try {
69071       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69072     } catch (std::out_of_range& e) {
69073       {
69074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69075       };
69076     } catch (std::exception& e) {
69077       {
69078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69079       };
69080     } catch (...) {
69081       {
69082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69083       };
69084     }
69085   }
69086   jresult = (void *)result;
69087   return jresult;
69088 }
69089
69090
69091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69092   void * jresult ;
69093   Dali::Toolkit::Scrollable *arg1 = 0 ;
69094   Dali::Toolkit::Scrollable *result = 0 ;
69095
69096   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69097   if (!arg1) {
69098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69099     return 0;
69100   }
69101   {
69102     try {
69103       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69104     } catch (std::out_of_range& e) {
69105       {
69106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69107       };
69108     } catch (std::exception& e) {
69109       {
69110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69111       };
69112     } catch (...) {
69113       {
69114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69115       };
69116     }
69117   }
69118   jresult = (void *)result;
69119   return jresult;
69120 }
69121
69122
69123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69124   void * jresult ;
69125   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69126   Dali::Toolkit::Scrollable *arg2 = 0 ;
69127   Dali::Toolkit::Scrollable *result = 0 ;
69128
69129   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69130   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69131   if (!arg2) {
69132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69133     return 0;
69134   }
69135   {
69136     try {
69137       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69138     } catch (std::out_of_range& e) {
69139       {
69140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69141       };
69142     } catch (std::exception& e) {
69143       {
69144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69145       };
69146     } catch (...) {
69147       {
69148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69149       };
69150     }
69151   }
69152   jresult = (void *)result;
69153   return jresult;
69154 }
69155
69156
69157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69158   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69159
69160   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69161   {
69162     try {
69163       delete arg1;
69164     } catch (std::out_of_range& e) {
69165       {
69166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69167       };
69168     } catch (std::exception& e) {
69169       {
69170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69171       };
69172     } catch (...) {
69173       {
69174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69175       };
69176     }
69177   }
69178 }
69179
69180
69181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69182   void * jresult ;
69183   Dali::BaseHandle arg1 ;
69184   Dali::BaseHandle *argp1 ;
69185   Dali::Toolkit::Scrollable result;
69186
69187   argp1 = (Dali::BaseHandle *)jarg1;
69188   if (!argp1) {
69189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69190     return 0;
69191   }
69192   arg1 = *argp1;
69193   {
69194     try {
69195       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69196     } catch (std::out_of_range& e) {
69197       {
69198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69199       };
69200     } catch (std::exception& e) {
69201       {
69202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69203       };
69204     } catch (...) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69207       };
69208     }
69209   }
69210   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69211   return jresult;
69212 }
69213
69214
69215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69216   unsigned int jresult ;
69217   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69218   bool result;
69219
69220   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69221   {
69222     try {
69223       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69224     } catch (std::out_of_range& e) {
69225       {
69226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69227       };
69228     } catch (std::exception& e) {
69229       {
69230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69231       };
69232     } catch (...) {
69233       {
69234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69235       };
69236     }
69237   }
69238   jresult = result;
69239   return jresult;
69240 }
69241
69242
69243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69244   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69245   bool arg2 ;
69246
69247   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69248   arg2 = jarg2 ? true : false;
69249   {
69250     try {
69251       (arg1)->SetOvershootEnabled(arg2);
69252     } catch (std::out_of_range& e) {
69253       {
69254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69255       };
69256     } catch (std::exception& e) {
69257       {
69258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (...) {
69261       {
69262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69263       };
69264     }
69265   }
69266 }
69267
69268
69269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69270   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69271   Dali::Vector4 *arg2 = 0 ;
69272
69273   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69274   arg2 = (Dali::Vector4 *)jarg2;
69275   if (!arg2) {
69276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69277     return ;
69278   }
69279   {
69280     try {
69281       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69282     } catch (std::out_of_range& e) {
69283       {
69284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69285       };
69286     } catch (std::exception& e) {
69287       {
69288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69289       };
69290     } catch (...) {
69291       {
69292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69293       };
69294     }
69295   }
69296 }
69297
69298
69299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69300   void * jresult ;
69301   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69302   Dali::Vector4 result;
69303
69304   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69305   {
69306     try {
69307       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69308     } catch (std::out_of_range& e) {
69309       {
69310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (std::exception& e) {
69313       {
69314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69319       };
69320     }
69321   }
69322   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69323   return jresult;
69324 }
69325
69326
69327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69328   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69329   float arg2 ;
69330
69331   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69332   arg2 = (float)jarg2;
69333   {
69334     try {
69335       (arg1)->SetOvershootAnimationSpeed(arg2);
69336     } catch (std::out_of_range& e) {
69337       {
69338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69339       };
69340     } catch (std::exception& e) {
69341       {
69342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69343       };
69344     } catch (...) {
69345       {
69346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69347       };
69348     }
69349   }
69350 }
69351
69352
69353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69354   float jresult ;
69355   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69356   float result;
69357
69358   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69359   {
69360     try {
69361       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69362     } catch (std::out_of_range& e) {
69363       {
69364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69365       };
69366     } catch (std::exception& e) {
69367       {
69368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69369       };
69370     } catch (...) {
69371       {
69372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69373       };
69374     }
69375   }
69376   jresult = result;
69377   return jresult;
69378 }
69379
69380
69381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69382   void * jresult ;
69383   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69384   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69385
69386   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69387   {
69388     try {
69389       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69390     } catch (std::out_of_range& e) {
69391       {
69392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69393       };
69394     } catch (std::exception& e) {
69395       {
69396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69397       };
69398     } catch (...) {
69399       {
69400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69401       };
69402     }
69403   }
69404   jresult = (void *)result;
69405   return jresult;
69406 }
69407
69408
69409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69410   void * jresult ;
69411   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69412   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69413
69414   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69415   {
69416     try {
69417       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69418     } catch (std::out_of_range& e) {
69419       {
69420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69421       };
69422     } catch (std::exception& e) {
69423       {
69424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69425       };
69426     } catch (...) {
69427       {
69428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69429       };
69430     }
69431   }
69432   jresult = (void *)result;
69433   return jresult;
69434 }
69435
69436
69437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69438   void * jresult ;
69439   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69440   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69441
69442   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69443   {
69444     try {
69445       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69446     } catch (std::out_of_range& e) {
69447       {
69448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69449       };
69450     } catch (std::exception& e) {
69451       {
69452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69453       };
69454     } catch (...) {
69455       {
69456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69457       };
69458     }
69459   }
69460   jresult = (void *)result;
69461   return jresult;
69462 }
69463
69464
69465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69466   unsigned int jresult ;
69467   Dali::Toolkit::ControlOrientation::Type arg1 ;
69468   bool result;
69469
69470   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69471   {
69472     try {
69473       result = (bool)Dali::Toolkit::IsVertical(arg1);
69474     } catch (std::out_of_range& e) {
69475       {
69476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69477       };
69478     } catch (std::exception& e) {
69479       {
69480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69481       };
69482     } catch (...) {
69483       {
69484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69485       };
69486     }
69487   }
69488   jresult = result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69494   unsigned int jresult ;
69495   Dali::Toolkit::ControlOrientation::Type arg1 ;
69496   bool result;
69497
69498   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69499   {
69500     try {
69501       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69502     } catch (std::out_of_range& e) {
69503       {
69504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69505       };
69506     } catch (std::exception& e) {
69507       {
69508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69509       };
69510     } catch (...) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69513       };
69514     }
69515   }
69516   jresult = result;
69517   return jresult;
69518 }
69519
69520
69521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69522   void * jresult ;
69523   unsigned int arg1 ;
69524   unsigned int arg2 ;
69525   Dali::Toolkit::ItemRange *result = 0 ;
69526
69527   arg1 = (unsigned int)jarg1;
69528   arg2 = (unsigned int)jarg2;
69529   {
69530     try {
69531       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69532     } catch (std::out_of_range& e) {
69533       {
69534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69535       };
69536     } catch (std::exception& e) {
69537       {
69538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69539       };
69540     } catch (...) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69543       };
69544     }
69545   }
69546   jresult = (void *)result;
69547   return jresult;
69548 }
69549
69550
69551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69552   void * jresult ;
69553   Dali::Toolkit::ItemRange *arg1 = 0 ;
69554   Dali::Toolkit::ItemRange *result = 0 ;
69555
69556   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69557   if (!arg1) {
69558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69559     return 0;
69560   }
69561   {
69562     try {
69563       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69564     } catch (std::out_of_range& e) {
69565       {
69566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69567       };
69568     } catch (std::exception& e) {
69569       {
69570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69571       };
69572     } catch (...) {
69573       {
69574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69575       };
69576     }
69577   }
69578   jresult = (void *)result;
69579   return jresult;
69580 }
69581
69582
69583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69584   void * jresult ;
69585   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69586   Dali::Toolkit::ItemRange *arg2 = 0 ;
69587   Dali::Toolkit::ItemRange *result = 0 ;
69588
69589   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69590   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69591   if (!arg2) {
69592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69593     return 0;
69594   }
69595   {
69596     try {
69597       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69598     } catch (std::out_of_range& e) {
69599       {
69600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69601       };
69602     } catch (std::exception& e) {
69603       {
69604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69605       };
69606     } catch (...) {
69607       {
69608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69609       };
69610     }
69611   }
69612   jresult = (void *)result;
69613   return jresult;
69614 }
69615
69616
69617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69618   unsigned int jresult ;
69619   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69620   unsigned int arg2 ;
69621   bool result;
69622
69623   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69624   arg2 = (unsigned int)jarg2;
69625   {
69626     try {
69627       result = (bool)(arg1)->Within(arg2);
69628     } catch (std::out_of_range& e) {
69629       {
69630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69631       };
69632     } catch (std::exception& e) {
69633       {
69634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69635       };
69636     } catch (...) {
69637       {
69638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69639       };
69640     }
69641   }
69642   jresult = result;
69643   return jresult;
69644 }
69645
69646
69647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69648   void * jresult ;
69649   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69650   Dali::Toolkit::ItemRange *arg2 = 0 ;
69651   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69652
69653   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69654   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69655   if (!arg2) {
69656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69657     return 0;
69658   }
69659   {
69660     try {
69661       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69662     } catch (std::out_of_range& e) {
69663       {
69664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69665       };
69666     } catch (std::exception& e) {
69667       {
69668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69669       };
69670     } catch (...) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69673       };
69674     }
69675   }
69676   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69677   return jresult;
69678 }
69679
69680
69681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin = arg2;
69688 }
69689
69690
69691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_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)->begin);
69698   jresult = result;
69699   return jresult;
69700 }
69701
69702
69703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69704   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69705   unsigned int arg2 ;
69706
69707   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69708   arg2 = (unsigned int)jarg2;
69709   if (arg1) (arg1)->end = arg2;
69710 }
69711
69712
69713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69714   unsigned int jresult ;
69715   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69716   unsigned int result;
69717
69718   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69719   result = (unsigned int) ((arg1)->end);
69720   jresult = result;
69721   return jresult;
69722 }
69723
69724
69725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69726   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69727
69728   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69729   {
69730     try {
69731       delete arg1;
69732     } catch (std::out_of_range& e) {
69733       {
69734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69735       };
69736     } catch (std::exception& e) {
69737       {
69738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69739       };
69740     } catch (...) {
69741       {
69742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69743       };
69744     }
69745   }
69746 }
69747
69748
69749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69750   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69751
69752   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69753   {
69754     try {
69755       delete arg1;
69756     } catch (std::out_of_range& e) {
69757       {
69758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69759       };
69760     } catch (std::exception& e) {
69761       {
69762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69763       };
69764     } catch (...) {
69765       {
69766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69767       };
69768     }
69769   }
69770 }
69771
69772
69773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69774   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69775   Dali::Toolkit::ControlOrientation::Type arg2 ;
69776
69777   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69778   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69779   {
69780     try {
69781       (arg1)->SetOrientation(arg2);
69782     } catch (std::out_of_range& e) {
69783       {
69784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69785       };
69786     } catch (std::exception& e) {
69787       {
69788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69789       };
69790     } catch (...) {
69791       {
69792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69793       };
69794     }
69795   }
69796 }
69797
69798
69799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69800   int jresult ;
69801   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69802   Dali::Toolkit::ControlOrientation::Type result;
69803
69804   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69805   {
69806     try {
69807       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69815       };
69816     } catch (...) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69819       };
69820     }
69821   }
69822   jresult = (int)result;
69823   return jresult;
69824 }
69825
69826
69827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69828   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69829   Dali::Property::Map *arg2 = 0 ;
69830
69831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69832   arg2 = (Dali::Property::Map *)jarg2;
69833   if (!arg2) {
69834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69835     return ;
69836   }
69837   {
69838     try {
69839       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69840     } catch (std::out_of_range& e) {
69841       {
69842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69843       };
69844     } catch (std::exception& e) {
69845       {
69846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69847       };
69848     } catch (...) {
69849       {
69850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69851       };
69852     }
69853   }
69854 }
69855
69856
69857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69858   void * jresult ;
69859   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69860   Dali::Property::Map result;
69861
69862   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69863   {
69864     try {
69865       result = (arg1)->GetLayoutProperties();
69866     } catch (std::out_of_range& e) {
69867       {
69868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69869       };
69870     } catch (std::exception& e) {
69871       {
69872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69873       };
69874     } catch (...) {
69875       {
69876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69877       };
69878     }
69879   }
69880   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69881   return jresult;
69882 }
69883
69884
69885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69886   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69887   unsigned int arg2 ;
69888   Dali::Vector3 *arg3 = 0 ;
69889   Dali::Vector3 *arg4 = 0 ;
69890
69891   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69892   arg2 = (unsigned int)jarg2;
69893   arg3 = (Dali::Vector3 *)jarg3;
69894   if (!arg3) {
69895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69896     return ;
69897   }
69898   arg4 = (Dali::Vector3 *)jarg4;
69899   if (!arg4) {
69900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69901     return ;
69902   }
69903   {
69904     try {
69905       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69906     } catch (std::out_of_range& e) {
69907       {
69908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69909       };
69910     } catch (std::exception& e) {
69911       {
69912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69913       };
69914     } catch (...) {
69915       {
69916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69917       };
69918     }
69919   }
69920 }
69921
69922
69923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69924   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69925   Dali::Vector3 *arg2 = 0 ;
69926
69927   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69928   arg2 = (Dali::Vector3 *)jarg2;
69929   if (!arg2) {
69930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69931     return ;
69932   }
69933   {
69934     try {
69935       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69936     } catch (std::out_of_range& e) {
69937       {
69938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69939       };
69940     } catch (std::exception& e) {
69941       {
69942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69943       };
69944     } catch (...) {
69945       {
69946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69947       };
69948     }
69949   }
69950 }
69951
69952
69953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69954   float jresult ;
69955   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69956   unsigned int arg2 ;
69957   Dali::Vector3 arg3 ;
69958   Dali::Vector3 *argp3 ;
69959   float result;
69960
69961   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69962   arg2 = (unsigned int)jarg2;
69963   argp3 = (Dali::Vector3 *)jarg3;
69964   if (!argp3) {
69965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69966     return 0;
69967   }
69968   arg3 = *argp3;
69969   {
69970     try {
69971       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69972     } catch (std::out_of_range& e) {
69973       {
69974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (std::exception& e) {
69977       {
69978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69979       };
69980     } catch (...) {
69981       {
69982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69983       };
69984     }
69985   }
69986   jresult = result;
69987   return jresult;
69988 }
69989
69990
69991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69992   float jresult ;
69993   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69994   float arg2 ;
69995   float result;
69996
69997   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69998   arg2 = (float)jarg2;
69999   {
70000     try {
70001       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70002     } catch (std::out_of_range& e) {
70003       {
70004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70005       };
70006     } catch (std::exception& e) {
70007       {
70008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70009       };
70010     } catch (...) {
70011       {
70012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70013       };
70014     }
70015   }
70016   jresult = result;
70017   return jresult;
70018 }
70019
70020
70021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70022   float jresult ;
70023   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70024   unsigned int arg2 ;
70025   float result;
70026
70027   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70028   arg2 = (unsigned int)jarg2;
70029   {
70030     try {
70031       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70032     } catch (std::out_of_range& e) {
70033       {
70034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70035       };
70036     } catch (std::exception& e) {
70037       {
70038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70039       };
70040     } catch (...) {
70041       {
70042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70043       };
70044     }
70045   }
70046   jresult = result;
70047   return jresult;
70048 }
70049
70050
70051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70052   void * jresult ;
70053   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70054   float arg2 ;
70055   Dali::Vector3 arg3 ;
70056   Dali::Vector3 *argp3 ;
70057   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70058
70059   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70060   arg2 = (float)jarg2;
70061   argp3 = (Dali::Vector3 *)jarg3;
70062   if (!argp3) {
70063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70064     return 0;
70065   }
70066   arg3 = *argp3;
70067   {
70068     try {
70069       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70070     } catch (std::out_of_range& e) {
70071       {
70072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70073       };
70074     } catch (std::exception& e) {
70075       {
70076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (...) {
70079       {
70080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70081       };
70082     }
70083   }
70084   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70085   return jresult;
70086 }
70087
70088
70089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70090   float jresult ;
70091   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70092   int arg2 ;
70093   float arg3 ;
70094   Dali::Vector3 *arg4 = 0 ;
70095   float result;
70096
70097   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70098   arg2 = (int)jarg2;
70099   arg3 = (float)jarg3;
70100   arg4 = (Dali::Vector3 *)jarg4;
70101   if (!arg4) {
70102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70103     return 0;
70104   }
70105   {
70106     try {
70107       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70108     } catch (std::out_of_range& e) {
70109       {
70110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70111       };
70112     } catch (std::exception& e) {
70113       {
70114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70115       };
70116     } catch (...) {
70117       {
70118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70119       };
70120     }
70121   }
70122   jresult = result;
70123   return jresult;
70124 }
70125
70126
70127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70128   unsigned int jresult ;
70129   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70130   Dali::Vector3 arg2 ;
70131   Dali::Vector3 *argp2 ;
70132   unsigned int result;
70133
70134   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70135   argp2 = (Dali::Vector3 *)jarg2;
70136   if (!argp2) {
70137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70138     return 0;
70139   }
70140   arg2 = *argp2;
70141   {
70142     try {
70143       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70144     } catch (std::out_of_range& e) {
70145       {
70146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70147       };
70148     } catch (std::exception& e) {
70149       {
70150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70151       };
70152     } catch (...) {
70153       {
70154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70155       };
70156     }
70157   }
70158   jresult = result;
70159   return jresult;
70160 }
70161
70162
70163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70164   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70165   unsigned int arg2 ;
70166   Dali::Vector3 *arg3 = 0 ;
70167   Dali::Vector3 *arg4 = 0 ;
70168
70169   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70170   arg2 = (unsigned int)jarg2;
70171   arg3 = (Dali::Vector3 *)jarg3;
70172   if (!arg3) {
70173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70174     return ;
70175   }
70176   arg4 = (Dali::Vector3 *)jarg4;
70177   if (!arg4) {
70178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70179     return ;
70180   }
70181   {
70182     try {
70183       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70184     } catch (std::out_of_range& e) {
70185       {
70186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70187       };
70188     } catch (std::exception& e) {
70189       {
70190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70191       };
70192     } catch (...) {
70193       {
70194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70195       };
70196     }
70197   }
70198 }
70199
70200
70201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70202   void * jresult ;
70203   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70204   Dali::Degree result;
70205
70206   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70207   {
70208     try {
70209       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70210     } catch (std::out_of_range& e) {
70211       {
70212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70213       };
70214     } catch (std::exception& e) {
70215       {
70216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70217       };
70218     } catch (...) {
70219       {
70220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70221       };
70222     }
70223   }
70224   jresult = new Dali::Degree((const Dali::Degree &)result);
70225   return jresult;
70226 }
70227
70228
70229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70230   float jresult ;
70231   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70232   float result;
70233
70234   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70235   {
70236     try {
70237       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70238     } catch (std::out_of_range& e) {
70239       {
70240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70241       };
70242     } catch (std::exception& e) {
70243       {
70244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70245       };
70246     } catch (...) {
70247       {
70248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70249       };
70250     }
70251   }
70252   jresult = result;
70253   return jresult;
70254 }
70255
70256
70257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70258   float jresult ;
70259   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70260   float result;
70261
70262   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70263   {
70264     try {
70265       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70266     } catch (std::out_of_range& e) {
70267       {
70268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70269       };
70270     } catch (std::exception& e) {
70271       {
70272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70273       };
70274     } catch (...) {
70275       {
70276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70277       };
70278     }
70279   }
70280   jresult = result;
70281   return jresult;
70282 }
70283
70284
70285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70286   float jresult ;
70287   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70288   float result;
70289
70290   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70291   {
70292     try {
70293       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70294     } catch (std::out_of_range& e) {
70295       {
70296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70297       };
70298     } catch (std::exception& e) {
70299       {
70300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70301       };
70302     } catch (...) {
70303       {
70304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70305       };
70306     }
70307   }
70308   jresult = result;
70309   return jresult;
70310 }
70311
70312
70313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70314   int jresult ;
70315   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70316   int arg2 ;
70317   int arg3 ;
70318   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70319   bool arg5 ;
70320   int result;
70321
70322   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70323   arg2 = (int)jarg2;
70324   arg3 = (int)jarg3;
70325   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70326   arg5 = jarg5 ? true : false;
70327   {
70328     try {
70329       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70330     } catch (std::out_of_range& e) {
70331       {
70332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70333       };
70334     } catch (std::exception& e) {
70335       {
70336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70337       };
70338     } catch (...) {
70339       {
70340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70341       };
70342     }
70343   }
70344   jresult = result;
70345   return jresult;
70346 }
70347
70348
70349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70350   float jresult ;
70351   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70352   float result;
70353
70354   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70355   {
70356     try {
70357       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70358     } catch (std::out_of_range& e) {
70359       {
70360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70361       };
70362     } catch (std::exception& e) {
70363       {
70364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70365       };
70366     } catch (...) {
70367       {
70368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70369       };
70370     }
70371   }
70372   jresult = result;
70373   return jresult;
70374 }
70375
70376
70377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70378   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70379   Dali::Actor *arg2 = 0 ;
70380   int arg3 ;
70381   Dali::Vector3 *arg4 = 0 ;
70382   Dali::Actor *arg5 = 0 ;
70383
70384   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70385   arg2 = (Dali::Actor *)jarg2;
70386   if (!arg2) {
70387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70388     return ;
70389   }
70390   arg3 = (int)jarg3;
70391   arg4 = (Dali::Vector3 *)jarg4;
70392   if (!arg4) {
70393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70394     return ;
70395   }
70396   arg5 = (Dali::Actor *)jarg5;
70397   if (!arg5) {
70398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70399     return ;
70400   }
70401   {
70402     try {
70403       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70404     } catch (std::out_of_range& e) {
70405       {
70406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70407       };
70408     } catch (std::exception& e) {
70409       {
70410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70411       };
70412     } catch (...) {
70413       {
70414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70415       };
70416     }
70417   }
70418 }
70419
70420
70421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70422   void * jresult ;
70423   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70424   int arg2 ;
70425   float arg3 ;
70426   Dali::Vector3 *arg4 = 0 ;
70427   Dali::Vector3 result;
70428
70429   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70430   arg2 = (int)jarg2;
70431   arg3 = (float)jarg3;
70432   arg4 = (Dali::Vector3 *)jarg4;
70433   if (!arg4) {
70434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70435     return 0;
70436   }
70437   {
70438     try {
70439       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70440     } catch (std::out_of_range& e) {
70441       {
70442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70443       };
70444     } catch (std::exception& e) {
70445       {
70446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70447       };
70448     } catch (...) {
70449       {
70450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70451       };
70452     }
70453   }
70454   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70455   return jresult;
70456 }
70457
70458
70459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70460   void * jresult ;
70461   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70462   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70463
70464   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70465   {
70466     try {
70467       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70468     } catch (std::out_of_range& e) {
70469       {
70470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70471       };
70472     } catch (std::exception& e) {
70473       {
70474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70475       };
70476     } catch (...) {
70477       {
70478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70479       };
70480     }
70481   }
70482   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70483   return jresult;
70484 }
70485
70486
70487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70488   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70489
70490   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70491   {
70492     try {
70493       delete arg1;
70494     } catch (std::out_of_range& e) {
70495       {
70496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70497       };
70498     } catch (std::exception& e) {
70499       {
70500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70501       };
70502     } catch (...) {
70503       {
70504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70505       };
70506     }
70507   }
70508 }
70509
70510
70511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70512   unsigned int jresult ;
70513   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70514   unsigned int result;
70515
70516   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70517   {
70518     try {
70519       result = (unsigned int)(arg1)->GetNumberOfItems();
70520     } catch (std::out_of_range& e) {
70521       {
70522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (std::exception& e) {
70525       {
70526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (...) {
70529       {
70530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70531       };
70532     }
70533   }
70534   jresult = result;
70535   return jresult;
70536 }
70537
70538
70539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70540   void * jresult ;
70541   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70542   unsigned int arg2 ;
70543   Dali::Actor result;
70544
70545   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70546   arg2 = (unsigned int)jarg2;
70547   {
70548     try {
70549       result = (arg1)->NewItem(arg2);
70550     } catch (std::out_of_range& e) {
70551       {
70552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70553       };
70554     } catch (std::exception& e) {
70555       {
70556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70557       };
70558     } catch (...) {
70559       {
70560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70561       };
70562     }
70563   }
70564   jresult = new Dali::Actor((const Dali::Actor &)result);
70565   return jresult;
70566 }
70567
70568
70569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70570   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70571   unsigned int arg2 ;
70572   Dali::Actor arg3 ;
70573   Dali::Actor *argp3 ;
70574
70575   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70576   arg2 = (unsigned int)jarg2;
70577   argp3 = (Dali::Actor *)jarg3;
70578   if (!argp3) {
70579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70580     return ;
70581   }
70582   arg3 = *argp3;
70583   {
70584     try {
70585       (arg1)->ItemReleased(arg2,arg3);
70586     } catch (std::out_of_range& e) {
70587       {
70588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70589       };
70590     } catch (std::exception& e) {
70591       {
70592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70593       };
70594     } catch (...) {
70595       {
70596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70597       };
70598     }
70599   }
70600 }
70601
70602
70603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70604   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70605   unsigned int arg2 ;
70606   Dali::Actor arg3 ;
70607   Dali::Actor *argp3 ;
70608
70609   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70610   arg2 = (unsigned int)jarg2;
70611   argp3 = (Dali::Actor *)jarg3;
70612   if (!argp3) {
70613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70614     return ;
70615   }
70616   arg3 = *argp3;
70617   {
70618     try {
70619       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70620     } catch (std::out_of_range& e) {
70621       {
70622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70623       };
70624     } catch (std::exception& e) {
70625       {
70626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70631       };
70632     }
70633   }
70634 }
70635
70636
70637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70638   void * jresult ;
70639   Dali::Toolkit::ItemFactory *result = 0 ;
70640
70641   {
70642     try {
70643       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70644     } catch (std::out_of_range& e) {
70645       {
70646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70647       };
70648     } catch (std::exception& e) {
70649       {
70650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70651       };
70652     } catch (...) {
70653       {
70654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70655       };
70656     }
70657   }
70658   jresult = (void *)result;
70659   return jresult;
70660 }
70661
70662
70663 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) {
70664   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70665   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70666   if (director) {
70667     director->swig_connect_director(callback0, callback1, callback2);
70668   }
70669 }
70670
70671
70672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70673   int jresult ;
70674   int result;
70675
70676   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70677   jresult = (int)result;
70678   return jresult;
70679 }
70680
70681
70682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70683   int jresult ;
70684   int result;
70685
70686   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70687   jresult = (int)result;
70688   return jresult;
70689 }
70690
70691
70692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70693   int jresult ;
70694   int result;
70695
70696   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70697   jresult = (int)result;
70698   return jresult;
70699 }
70700
70701
70702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70703   int jresult ;
70704   int result;
70705
70706   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70707   jresult = (int)result;
70708   return jresult;
70709 }
70710
70711
70712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70713   int jresult ;
70714   int result;
70715
70716   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70717   jresult = (int)result;
70718   return jresult;
70719 }
70720
70721
70722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70723   int jresult ;
70724   int result;
70725
70726   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70727   jresult = (int)result;
70728   return jresult;
70729 }
70730
70731
70732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70733   int jresult ;
70734   int result;
70735
70736   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70737   jresult = (int)result;
70738   return jresult;
70739 }
70740
70741
70742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70743   int jresult ;
70744   int result;
70745
70746   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70747   jresult = (int)result;
70748   return jresult;
70749 }
70750
70751
70752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70753   int jresult ;
70754   int result;
70755
70756   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70757   jresult = (int)result;
70758   return jresult;
70759 }
70760
70761
70762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70763   int jresult ;
70764   int result;
70765
70766   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70767   jresult = (int)result;
70768   return jresult;
70769 }
70770
70771
70772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70773   int jresult ;
70774   int result;
70775
70776   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70777   jresult = (int)result;
70778   return jresult;
70779 }
70780
70781
70782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70783   void * jresult ;
70784   Dali::Toolkit::ItemView::Property *result = 0 ;
70785
70786   {
70787     try {
70788       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70789     } catch (std::out_of_range& e) {
70790       {
70791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (std::exception& e) {
70794       {
70795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70796       };
70797     } catch (...) {
70798       {
70799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70800       };
70801     }
70802   }
70803   jresult = (void *)result;
70804   return jresult;
70805 }
70806
70807
70808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70809   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70810
70811   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70812   {
70813     try {
70814       delete arg1;
70815     } catch (std::out_of_range& e) {
70816       {
70817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70818       };
70819     } catch (std::exception& e) {
70820       {
70821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70822       };
70823     } catch (...) {
70824       {
70825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70826       };
70827     }
70828   }
70829 }
70830
70831
70832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70833   void * jresult ;
70834   Dali::Toolkit::ItemView *result = 0 ;
70835
70836   {
70837     try {
70838       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70839     } catch (std::out_of_range& e) {
70840       {
70841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70842       };
70843     } catch (std::exception& e) {
70844       {
70845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70846       };
70847     } catch (...) {
70848       {
70849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70850       };
70851     }
70852   }
70853   jresult = (void *)result;
70854   return jresult;
70855 }
70856
70857
70858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70859   void * jresult ;
70860   Dali::Toolkit::ItemView *arg1 = 0 ;
70861   Dali::Toolkit::ItemView *result = 0 ;
70862
70863   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70864   if (!arg1) {
70865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70866     return 0;
70867   }
70868   {
70869     try {
70870       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70871     } catch (std::out_of_range& e) {
70872       {
70873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (std::exception& e) {
70876       {
70877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (...) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70882       };
70883     }
70884   }
70885   jresult = (void *)result;
70886   return jresult;
70887 }
70888
70889
70890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70891   void * jresult ;
70892   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70893   Dali::Toolkit::ItemView *arg2 = 0 ;
70894   Dali::Toolkit::ItemView *result = 0 ;
70895
70896   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70897   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70898   if (!arg2) {
70899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70900     return 0;
70901   }
70902   {
70903     try {
70904       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70905     } catch (std::out_of_range& e) {
70906       {
70907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70908       };
70909     } catch (std::exception& e) {
70910       {
70911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70912       };
70913     } catch (...) {
70914       {
70915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70916       };
70917     }
70918   }
70919   jresult = (void *)result;
70920   return jresult;
70921 }
70922
70923
70924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70925   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70926
70927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70928   {
70929     try {
70930       delete arg1;
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70938       };
70939     } catch (...) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70942       };
70943     }
70944   }
70945 }
70946
70947
70948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70949   void * jresult ;
70950   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70951   Dali::Toolkit::ItemView result;
70952
70953   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70954   if (!arg1) {
70955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70956     return 0;
70957   }
70958   {
70959     try {
70960       result = Dali::Toolkit::ItemView::New(*arg1);
70961     } catch (std::out_of_range& e) {
70962       {
70963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70964       };
70965     } catch (std::exception& e) {
70966       {
70967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70968       };
70969     } catch (...) {
70970       {
70971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70972       };
70973     }
70974   }
70975   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70976   return jresult;
70977 }
70978
70979
70980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70981   void * jresult ;
70982   Dali::BaseHandle arg1 ;
70983   Dali::BaseHandle *argp1 ;
70984   Dali::Toolkit::ItemView result;
70985
70986   argp1 = (Dali::BaseHandle *)jarg1;
70987   if (!argp1) {
70988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70989     return 0;
70990   }
70991   arg1 = *argp1;
70992   {
70993     try {
70994       result = Dali::Toolkit::ItemView::DownCast(arg1);
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (...) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71006       };
71007     }
71008   }
71009   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71010   return jresult;
71011 }
71012
71013
71014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71015   unsigned int jresult ;
71016   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71017   unsigned int result;
71018
71019   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71020   {
71021     try {
71022       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71023     } catch (std::out_of_range& e) {
71024       {
71025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71026       };
71027     } catch (std::exception& e) {
71028       {
71029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71030       };
71031     } catch (...) {
71032       {
71033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71034       };
71035     }
71036   }
71037   jresult = result;
71038   return jresult;
71039 }
71040
71041
71042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71043   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71044   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71045
71046   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71047   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71048   if (!arg2) {
71049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71050     return ;
71051   }
71052   {
71053     try {
71054       (arg1)->AddLayout(*arg2);
71055     } catch (std::out_of_range& e) {
71056       {
71057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71058       };
71059     } catch (std::exception& e) {
71060       {
71061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71062       };
71063     } catch (...) {
71064       {
71065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71066       };
71067     }
71068   }
71069 }
71070
71071
71072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71074   unsigned int arg2 ;
71075
71076   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71077   arg2 = (unsigned int)jarg2;
71078   {
71079     try {
71080       (arg1)->RemoveLayout(arg2);
71081     } catch (std::out_of_range& e) {
71082       {
71083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71084       };
71085     } catch (std::exception& e) {
71086       {
71087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71088       };
71089     } catch (...) {
71090       {
71091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71092       };
71093     }
71094   }
71095 }
71096
71097
71098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71099   void * jresult ;
71100   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71101   unsigned int arg2 ;
71102   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71103
71104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71105   arg2 = (unsigned int)jarg2;
71106   {
71107     try {
71108       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71109     } catch (std::out_of_range& e) {
71110       {
71111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71112       };
71113     } catch (std::exception& e) {
71114       {
71115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71116       };
71117     } catch (...) {
71118       {
71119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71120       };
71121     }
71122   }
71123   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71124   return jresult;
71125 }
71126
71127
71128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71129   void * jresult ;
71130   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71131   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71132
71133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71134   {
71135     try {
71136       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71137     } catch (std::out_of_range& e) {
71138       {
71139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (std::exception& e) {
71142       {
71143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71144       };
71145     } catch (...) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71148       };
71149     }
71150   }
71151   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71152   return jresult;
71153 }
71154
71155
71156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71157   float jresult ;
71158   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71159   Dali::Toolkit::ItemId arg2 ;
71160   float result;
71161
71162   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71163   arg2 = (Dali::Toolkit::ItemId)jarg2;
71164   {
71165     try {
71166       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71167     } catch (std::out_of_range& e) {
71168       {
71169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71170       };
71171     } catch (std::exception& e) {
71172       {
71173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (...) {
71176       {
71177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71178       };
71179     }
71180   }
71181   jresult = result;
71182   return jresult;
71183 }
71184
71185
71186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71187   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71188   unsigned int arg2 ;
71189   Dali::Vector3 arg3 ;
71190   float arg4 ;
71191   Dali::Vector3 *argp3 ;
71192
71193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71194   arg2 = (unsigned int)jarg2;
71195   argp3 = (Dali::Vector3 *)jarg3;
71196   if (!argp3) {
71197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71198     return ;
71199   }
71200   arg3 = *argp3;
71201   arg4 = (float)jarg4;
71202   {
71203     try {
71204       (arg1)->ActivateLayout(arg2,arg3,arg4);
71205     } catch (std::out_of_range& e) {
71206       {
71207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71208       };
71209     } catch (std::exception& e) {
71210       {
71211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71212       };
71213     } catch (...) {
71214       {
71215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71216       };
71217     }
71218   }
71219 }
71220
71221
71222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71223   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71224
71225   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71226   {
71227     try {
71228       (arg1)->DeactivateCurrentLayout();
71229     } catch (std::out_of_range& e) {
71230       {
71231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71232       };
71233     } catch (std::exception& e) {
71234       {
71235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71236       };
71237     } catch (...) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71240       };
71241     }
71242   }
71243 }
71244
71245
71246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71247   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71248   float arg2 ;
71249
71250   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71251   arg2 = (float)jarg2;
71252   {
71253     try {
71254       (arg1)->SetMinimumSwipeSpeed(arg2);
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71262       };
71263     } catch (...) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71266       };
71267     }
71268   }
71269 }
71270
71271
71272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71273   float jresult ;
71274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71275   float result;
71276
71277   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71278   {
71279     try {
71280       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71281     } catch (std::out_of_range& e) {
71282       {
71283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71284       };
71285     } catch (std::exception& e) {
71286       {
71287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71288       };
71289     } catch (...) {
71290       {
71291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71292       };
71293     }
71294   }
71295   jresult = result;
71296   return jresult;
71297 }
71298
71299
71300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71301   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71302   float arg2 ;
71303
71304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71305   arg2 = (float)jarg2;
71306   {
71307     try {
71308       (arg1)->SetMinimumSwipeDistance(arg2);
71309     } catch (std::out_of_range& e) {
71310       {
71311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71312       };
71313     } catch (std::exception& e) {
71314       {
71315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71316       };
71317     } catch (...) {
71318       {
71319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71320       };
71321     }
71322   }
71323 }
71324
71325
71326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71327   float jresult ;
71328   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71329   float result;
71330
71331   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71332   {
71333     try {
71334       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71346       };
71347     }
71348   }
71349   jresult = result;
71350   return jresult;
71351 }
71352
71353
71354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71355   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71356   float arg2 ;
71357
71358   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71359   arg2 = (float)jarg2;
71360   {
71361     try {
71362       (arg1)->SetWheelScrollDistanceStep(arg2);
71363     } catch (std::out_of_range& e) {
71364       {
71365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71366       };
71367     } catch (std::exception& e) {
71368       {
71369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71370       };
71371     } catch (...) {
71372       {
71373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71374       };
71375     }
71376   }
71377 }
71378
71379
71380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71381   float jresult ;
71382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71383   float result;
71384
71385   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71386   {
71387     try {
71388       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71389     } catch (std::out_of_range& e) {
71390       {
71391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71392       };
71393     } catch (std::exception& e) {
71394       {
71395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71396       };
71397     } catch (...) {
71398       {
71399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71400       };
71401     }
71402   }
71403   jresult = result;
71404   return jresult;
71405 }
71406
71407
71408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71409   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71410   bool arg2 ;
71411
71412   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71413   arg2 = jarg2 ? true : false;
71414   {
71415     try {
71416       (arg1)->SetAnchoring(arg2);
71417     } catch (std::out_of_range& e) {
71418       {
71419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71420       };
71421     } catch (std::exception& e) {
71422       {
71423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71424       };
71425     } catch (...) {
71426       {
71427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71428       };
71429     }
71430   }
71431 }
71432
71433
71434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71435   unsigned int jresult ;
71436   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71437   bool result;
71438
71439   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71440   {
71441     try {
71442       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71443     } catch (std::out_of_range& e) {
71444       {
71445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71446       };
71447     } catch (std::exception& e) {
71448       {
71449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71450       };
71451     } catch (...) {
71452       {
71453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71454       };
71455     }
71456   }
71457   jresult = result;
71458   return jresult;
71459 }
71460
71461
71462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71463   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71464   float arg2 ;
71465
71466   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71467   arg2 = (float)jarg2;
71468   {
71469     try {
71470       (arg1)->SetAnchoringDuration(arg2);
71471     } catch (std::out_of_range& e) {
71472       {
71473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71474       };
71475     } catch (std::exception& e) {
71476       {
71477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71482       };
71483     }
71484   }
71485 }
71486
71487
71488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71489   float jresult ;
71490   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71491   float result;
71492
71493   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71494   {
71495     try {
71496       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71497     } catch (std::out_of_range& e) {
71498       {
71499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (std::exception& e) {
71502       {
71503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (...) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71508       };
71509     }
71510   }
71511   jresult = result;
71512   return jresult;
71513 }
71514
71515
71516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71517   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71518   Dali::Toolkit::ItemId arg2 ;
71519   float arg3 ;
71520
71521   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71522   arg2 = (Dali::Toolkit::ItemId)jarg2;
71523   arg3 = (float)jarg3;
71524   {
71525     try {
71526       (arg1)->ScrollToItem(arg2,arg3);
71527     } catch (std::out_of_range& e) {
71528       {
71529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71530       };
71531     } catch (std::exception& e) {
71532       {
71533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71534       };
71535     } catch (...) {
71536       {
71537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71538       };
71539     }
71540   }
71541 }
71542
71543
71544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71545   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71546   float arg2 ;
71547
71548   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71549   arg2 = (float)jarg2;
71550   {
71551     try {
71552       (arg1)->SetRefreshInterval(arg2);
71553     } catch (std::out_of_range& e) {
71554       {
71555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71556       };
71557     } catch (std::exception& e) {
71558       {
71559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71560       };
71561     } catch (...) {
71562       {
71563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71564       };
71565     }
71566   }
71567 }
71568
71569
71570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71571   float jresult ;
71572   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71573   float result;
71574
71575   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71576   {
71577     try {
71578       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71579     } catch (std::out_of_range& e) {
71580       {
71581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71582       };
71583     } catch (std::exception& e) {
71584       {
71585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71590       };
71591     }
71592   }
71593   jresult = result;
71594   return jresult;
71595 }
71596
71597
71598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71599   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71600
71601   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71602   {
71603     try {
71604       (arg1)->Refresh();
71605     } catch (std::out_of_range& e) {
71606       {
71607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71608       };
71609     } catch (std::exception& e) {
71610       {
71611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (...) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71616       };
71617     }
71618   }
71619 }
71620
71621
71622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71623   void * jresult ;
71624   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71625   Dali::Toolkit::ItemId arg2 ;
71626   Dali::Actor result;
71627
71628   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71629   arg2 = (Dali::Toolkit::ItemId)jarg2;
71630   {
71631     try {
71632       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71633     } catch (std::out_of_range& e) {
71634       {
71635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (std::exception& e) {
71638       {
71639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (...) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71644       };
71645     }
71646   }
71647   jresult = new Dali::Actor((const Dali::Actor &)result);
71648   return jresult;
71649 }
71650
71651
71652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71653   unsigned int jresult ;
71654   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71655   Dali::Actor arg2 ;
71656   Dali::Actor *argp2 ;
71657   Dali::Toolkit::ItemId result;
71658
71659   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71660   argp2 = (Dali::Actor *)jarg2;
71661   if (!argp2) {
71662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71663     return 0;
71664   }
71665   arg2 = *argp2;
71666   {
71667     try {
71668       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71676       };
71677     } catch (...) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71680       };
71681     }
71682   }
71683   jresult = result;
71684   return jresult;
71685 }
71686
71687
71688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71689   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71690   Dali::Toolkit::Item arg2 ;
71691   float arg3 ;
71692   Dali::Toolkit::Item *argp2 ;
71693
71694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71695   argp2 = (Dali::Toolkit::Item *)jarg2;
71696   if (!argp2) {
71697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71698     return ;
71699   }
71700   arg2 = *argp2;
71701   arg3 = (float)jarg3;
71702   {
71703     try {
71704       (arg1)->InsertItem(arg2,arg3);
71705     } catch (std::out_of_range& e) {
71706       {
71707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71708       };
71709     } catch (std::exception& e) {
71710       {
71711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71712       };
71713     } catch (...) {
71714       {
71715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71716       };
71717     }
71718   }
71719 }
71720
71721
71722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71724   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71725   float arg3 ;
71726
71727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71728   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71729   if (!arg2) {
71730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71731     return ;
71732   }
71733   arg3 = (float)jarg3;
71734   {
71735     try {
71736       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71737     } catch (std::out_of_range& e) {
71738       {
71739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71740       };
71741     } catch (std::exception& e) {
71742       {
71743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71744       };
71745     } catch (...) {
71746       {
71747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71748       };
71749     }
71750   }
71751 }
71752
71753
71754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71755   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71756   Dali::Toolkit::ItemId arg2 ;
71757   float arg3 ;
71758
71759   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71760   arg2 = (Dali::Toolkit::ItemId)jarg2;
71761   arg3 = (float)jarg3;
71762   {
71763     try {
71764       (arg1)->RemoveItem(arg2,arg3);
71765     } catch (std::out_of_range& e) {
71766       {
71767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71768       };
71769     } catch (std::exception& e) {
71770       {
71771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71772       };
71773     } catch (...) {
71774       {
71775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71776       };
71777     }
71778   }
71779 }
71780
71781
71782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71783   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71784   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71785   float arg3 ;
71786
71787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71788   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71789   if (!arg2) {
71790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71791     return ;
71792   }
71793   arg3 = (float)jarg3;
71794   {
71795     try {
71796       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71797     } catch (std::out_of_range& e) {
71798       {
71799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71800       };
71801     } catch (std::exception& e) {
71802       {
71803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71804       };
71805     } catch (...) {
71806       {
71807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71808       };
71809     }
71810   }
71811 }
71812
71813
71814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71815   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71816   Dali::Toolkit::Item arg2 ;
71817   float arg3 ;
71818   Dali::Toolkit::Item *argp2 ;
71819
71820   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71821   argp2 = (Dali::Toolkit::Item *)jarg2;
71822   if (!argp2) {
71823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71824     return ;
71825   }
71826   arg2 = *argp2;
71827   arg3 = (float)jarg3;
71828   {
71829     try {
71830       (arg1)->ReplaceItem(arg2,arg3);
71831     } catch (std::out_of_range& e) {
71832       {
71833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71834       };
71835     } catch (std::exception& e) {
71836       {
71837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71842       };
71843     }
71844   }
71845 }
71846
71847
71848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71850   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71851   float arg3 ;
71852
71853   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71854   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71855   if (!arg2) {
71856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71857     return ;
71858   }
71859   arg3 = (float)jarg3;
71860   {
71861     try {
71862       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71863     } catch (std::out_of_range& e) {
71864       {
71865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71866       };
71867     } catch (std::exception& e) {
71868       {
71869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71870       };
71871     } catch (...) {
71872       {
71873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71874       };
71875     }
71876   }
71877 }
71878
71879
71880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71882   Dali::Vector3 *arg2 = 0 ;
71883
71884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71885   arg2 = (Dali::Vector3 *)jarg2;
71886   if (!arg2) {
71887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71888     return ;
71889   }
71890   {
71891     try {
71892       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71893     } catch (std::out_of_range& e) {
71894       {
71895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (std::exception& e) {
71898       {
71899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71900       };
71901     } catch (...) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71904       };
71905     }
71906   }
71907 }
71908
71909
71910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71911   void * jresult ;
71912   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71913   Dali::Vector3 result;
71914
71915   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71916   {
71917     try {
71918       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (...) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71930       };
71931     }
71932   }
71933   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71934   return jresult;
71935 }
71936
71937
71938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71939   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71940   Dali::Vector3 *arg2 = 0 ;
71941
71942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71943   arg2 = (Dali::Vector3 *)jarg2;
71944   if (!arg2) {
71945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71946     return ;
71947   }
71948   {
71949     try {
71950       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71951     } catch (std::out_of_range& e) {
71952       {
71953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71954       };
71955     } catch (std::exception& e) {
71956       {
71957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71958       };
71959     } catch (...) {
71960       {
71961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71962       };
71963     }
71964   }
71965 }
71966
71967
71968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71969   void * jresult ;
71970   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71971   Dali::Vector3 result;
71972
71973   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71974   {
71975     try {
71976       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71977     } catch (std::out_of_range& e) {
71978       {
71979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71980       };
71981     } catch (std::exception& e) {
71982       {
71983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71984       };
71985     } catch (...) {
71986       {
71987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71988       };
71989     }
71990   }
71991   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71992   return jresult;
71993 }
71994
71995
71996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71997   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71998   Dali::Toolkit::ItemRange *arg2 = 0 ;
71999
72000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72001   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72002   if (!arg2) {
72003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72004     return ;
72005   }
72006   {
72007     try {
72008       (arg1)->GetItemsRange(*arg2);
72009     } catch (std::out_of_range& e) {
72010       {
72011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72012       };
72013     } catch (std::exception& e) {
72014       {
72015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72016       };
72017     } catch (...) {
72018       {
72019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72020       };
72021     }
72022   }
72023 }
72024
72025
72026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72027   void * jresult ;
72028   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72029   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72030
72031   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72032   {
72033     try {
72034       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72035     } catch (std::out_of_range& e) {
72036       {
72037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72038       };
72039     } catch (std::exception& e) {
72040       {
72041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72042       };
72043     } catch (...) {
72044       {
72045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72046       };
72047     }
72048   }
72049   jresult = (void *)result;
72050   return jresult;
72051 }
72052
72053
72054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72055   Dali::Vector3 *arg1 = 0 ;
72056   PropertyInputContainer *arg2 = 0 ;
72057
72058   arg1 = (Dali::Vector3 *)jarg1;
72059   if (!arg1) {
72060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72061     return ;
72062   }
72063   arg2 = (PropertyInputContainer *)jarg2;
72064   if (!arg2) {
72065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72066     return ;
72067   }
72068   {
72069     try {
72070       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72071     } catch (std::out_of_range& e) {
72072       {
72073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72074       };
72075     } catch (std::exception& e) {
72076       {
72077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72078       };
72079     } catch (...) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72082       };
72083     }
72084   }
72085 }
72086
72087
72088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72089   Dali::Vector3 *arg1 = 0 ;
72090   PropertyInputContainer *arg2 = 0 ;
72091
72092   arg1 = (Dali::Vector3 *)jarg1;
72093   if (!arg1) {
72094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72095     return ;
72096   }
72097   arg2 = (PropertyInputContainer *)jarg2;
72098   if (!arg2) {
72099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72100     return ;
72101   }
72102   {
72103     try {
72104       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72105     } catch (std::out_of_range& e) {
72106       {
72107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72108       };
72109     } catch (std::exception& e) {
72110       {
72111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72112       };
72113     } catch (...) {
72114       {
72115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72116       };
72117     }
72118   }
72119 }
72120
72121
72122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72123   void * jresult ;
72124   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72125
72126   {
72127     try {
72128       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72129     } catch (std::out_of_range& e) {
72130       {
72131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72132       };
72133     } catch (std::exception& e) {
72134       {
72135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72136       };
72137     } catch (...) {
72138       {
72139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72140       };
72141     }
72142   }
72143   jresult = (void *)result;
72144   return jresult;
72145 }
72146
72147
72148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72149   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72150
72151   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72152   {
72153     try {
72154       delete arg1;
72155     } catch (std::out_of_range& e) {
72156       {
72157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72158       };
72159     } catch (std::exception& e) {
72160       {
72161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72162       };
72163     } catch (...) {
72164       {
72165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72166       };
72167     }
72168   }
72169 }
72170
72171
72172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72173   void * jresult ;
72174   Dali::Path arg1 ;
72175   Dali::Vector3 *arg2 = 0 ;
72176   Dali::Property::Index arg3 ;
72177   Dali::Vector3 *arg4 = 0 ;
72178   unsigned int arg5 ;
72179   Dali::Path *argp1 ;
72180   Dali::Toolkit::ScrollViewPagePathEffect result;
72181
72182   argp1 = (Dali::Path *)jarg1;
72183   if (!argp1) {
72184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72185     return 0;
72186   }
72187   arg1 = *argp1;
72188   arg2 = (Dali::Vector3 *)jarg2;
72189   if (!arg2) {
72190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72191     return 0;
72192   }
72193   arg3 = (Dali::Property::Index)jarg3;
72194   arg4 = (Dali::Vector3 *)jarg4;
72195   if (!arg4) {
72196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72197     return 0;
72198   }
72199   arg5 = (unsigned int)jarg5;
72200   {
72201     try {
72202       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72203     } catch (std::out_of_range& e) {
72204       {
72205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72206       };
72207     } catch (std::exception& e) {
72208       {
72209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72210       };
72211     } catch (...) {
72212       {
72213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72214       };
72215     }
72216   }
72217   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72218   return jresult;
72219 }
72220
72221
72222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72223   void * jresult ;
72224   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72225
72226   {
72227     try {
72228       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72229     } catch (std::out_of_range& e) {
72230       {
72231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72232       };
72233     } catch (std::exception& e) {
72234       {
72235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72240       };
72241     }
72242   }
72243   jresult = (void *)result;
72244   return jresult;
72245 }
72246
72247
72248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72249   void * jresult ;
72250   Dali::BaseHandle arg1 ;
72251   Dali::BaseHandle *argp1 ;
72252   Dali::Toolkit::ScrollViewPagePathEffect result;
72253
72254   argp1 = (Dali::BaseHandle *)jarg1;
72255   if (!argp1) {
72256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72257     return 0;
72258   }
72259   arg1 = *argp1;
72260   {
72261     try {
72262       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72263     } catch (std::out_of_range& e) {
72264       {
72265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (std::exception& e) {
72268       {
72269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72270       };
72271     } catch (...) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72274       };
72275     }
72276   }
72277   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72278   return jresult;
72279 }
72280
72281
72282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72283   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72284   Dali::Actor arg2 ;
72285   unsigned int arg3 ;
72286   Dali::Actor *argp2 ;
72287
72288   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72289   argp2 = (Dali::Actor *)jarg2;
72290   if (!argp2) {
72291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72292     return ;
72293   }
72294   arg2 = *argp2;
72295   arg3 = (unsigned int)jarg3;
72296   {
72297     try {
72298       (arg1)->ApplyToPage(arg2,arg3);
72299     } catch (std::out_of_range& e) {
72300       {
72301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72302       };
72303     } catch (std::exception& e) {
72304       {
72305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72306       };
72307     } catch (...) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72310       };
72311     }
72312   }
72313 }
72314
72315
72316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72317   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72318
72319   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72320   {
72321     try {
72322       delete arg1;
72323     } catch (std::out_of_range& e) {
72324       {
72325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72326       };
72327     } catch (std::exception& e) {
72328       {
72329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72330       };
72331     } catch (...) {
72332       {
72333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72334       };
72335     }
72336   }
72337 }
72338
72339
72340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x = arg2;
72347 }
72348
72349
72350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_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)->x);
72357   jresult = (int)result;
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72363   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72364   Dali::Toolkit::ClampState arg2 ;
72365
72366   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72367   arg2 = (Dali::Toolkit::ClampState)jarg2;
72368   if (arg1) (arg1)->y = arg2;
72369 }
72370
72371
72372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72373   int jresult ;
72374   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72375   Dali::Toolkit::ClampState result;
72376
72377   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72378   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72379   jresult = (int)result;
72380   return jresult;
72381 }
72382
72383
72384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72385   void * jresult ;
72386   Dali::Toolkit::ClampState2D *result = 0 ;
72387
72388   {
72389     try {
72390       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72391     } catch (std::out_of_range& e) {
72392       {
72393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72394       };
72395     } catch (std::exception& e) {
72396       {
72397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72398       };
72399     } catch (...) {
72400       {
72401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72402       };
72403     }
72404   }
72405   jresult = (void *)result;
72406   return jresult;
72407 }
72408
72409
72410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72411   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72412
72413   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72414   {
72415     try {
72416       delete arg1;
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72424       };
72425     } catch (...) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72428       };
72429     }
72430   }
72431 }
72432
72433
72434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72435   void * jresult ;
72436   float arg1 ;
72437   float arg2 ;
72438   bool arg3 ;
72439   Dali::Toolkit::RulerDomain *result = 0 ;
72440
72441   arg1 = (float)jarg1;
72442   arg2 = (float)jarg2;
72443   arg3 = jarg3 ? true : false;
72444   {
72445     try {
72446       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72447     } catch (std::out_of_range& e) {
72448       {
72449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72450       };
72451     } catch (std::exception& e) {
72452       {
72453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72454       };
72455     } catch (...) {
72456       {
72457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72458       };
72459     }
72460   }
72461   jresult = (void *)result;
72462   return jresult;
72463 }
72464
72465
72466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72467   void * jresult ;
72468   float arg1 ;
72469   float arg2 ;
72470   Dali::Toolkit::RulerDomain *result = 0 ;
72471
72472   arg1 = (float)jarg1;
72473   arg2 = (float)jarg2;
72474   {
72475     try {
72476       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (...) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72488       };
72489     }
72490   }
72491   jresult = (void *)result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min = arg2;
72503 }
72504
72505
72506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_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)->min);
72513   jresult = result;
72514   return jresult;
72515 }
72516
72517
72518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72519   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72520   float arg2 ;
72521
72522   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72523   arg2 = (float)jarg2;
72524   if (arg1) (arg1)->max = arg2;
72525 }
72526
72527
72528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72529   float jresult ;
72530   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72531   float result;
72532
72533   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72534   result = (float) ((arg1)->max);
72535   jresult = result;
72536   return jresult;
72537 }
72538
72539
72540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72541   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72542   bool arg2 ;
72543
72544   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72545   arg2 = jarg2 ? true : false;
72546   if (arg1) (arg1)->enabled = arg2;
72547 }
72548
72549
72550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72551   unsigned int jresult ;
72552   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72553   bool result;
72554
72555   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72556   result = (bool) ((arg1)->enabled);
72557   jresult = result;
72558   return jresult;
72559 }
72560
72561
72562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72563   float jresult ;
72564   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72565   float arg2 ;
72566   float arg3 ;
72567   float arg4 ;
72568   float result;
72569
72570   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72571   arg2 = (float)jarg2;
72572   arg3 = (float)jarg3;
72573   arg4 = (float)jarg4;
72574   {
72575     try {
72576       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72577     } catch (std::out_of_range& e) {
72578       {
72579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72580       };
72581     } catch (std::exception& e) {
72582       {
72583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72584       };
72585     } catch (...) {
72586       {
72587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72588       };
72589     }
72590   }
72591   jresult = result;
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72597   float jresult ;
72598   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72599   float arg2 ;
72600   float arg3 ;
72601   float result;
72602
72603   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72604   arg2 = (float)jarg2;
72605   arg3 = (float)jarg3;
72606   {
72607     try {
72608       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72609     } catch (std::out_of_range& e) {
72610       {
72611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72612       };
72613     } catch (std::exception& e) {
72614       {
72615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72616       };
72617     } catch (...) {
72618       {
72619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72620       };
72621     }
72622   }
72623   jresult = result;
72624   return jresult;
72625 }
72626
72627
72628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72629   float jresult ;
72630   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72631   float arg2 ;
72632   float result;
72633
72634   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72635   arg2 = (float)jarg2;
72636   {
72637     try {
72638       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72639     } catch (std::out_of_range& e) {
72640       {
72641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72642       };
72643     } catch (std::exception& e) {
72644       {
72645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72646       };
72647     } catch (...) {
72648       {
72649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72650       };
72651     }
72652   }
72653   jresult = result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72659   float jresult ;
72660   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72661   float arg2 ;
72662   float arg3 ;
72663   float arg4 ;
72664   Dali::Toolkit::ClampState *arg5 = 0 ;
72665   float result;
72666
72667   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72668   arg2 = (float)jarg2;
72669   arg3 = (float)jarg3;
72670   arg4 = (float)jarg4;
72671   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72672   if (!arg5) {
72673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72674     return 0;
72675   }
72676   {
72677     try {
72678       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72679     } catch (std::out_of_range& e) {
72680       {
72681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72682       };
72683     } catch (std::exception& e) {
72684       {
72685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72686       };
72687     } catch (...) {
72688       {
72689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72690       };
72691     }
72692   }
72693   jresult = result;
72694   return jresult;
72695 }
72696
72697
72698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72699   float jresult ;
72700   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72701   float result;
72702
72703   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72704   {
72705     try {
72706       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72707     } catch (std::out_of_range& e) {
72708       {
72709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72710       };
72711     } catch (std::exception& e) {
72712       {
72713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72714       };
72715     } catch (...) {
72716       {
72717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72718       };
72719     }
72720   }
72721   jresult = result;
72722   return jresult;
72723 }
72724
72725
72726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72727   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72728
72729   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72730   {
72731     try {
72732       delete arg1;
72733     } catch (std::out_of_range& e) {
72734       {
72735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72736       };
72737     } catch (std::exception& e) {
72738       {
72739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72740       };
72741     } catch (...) {
72742       {
72743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72744       };
72745     }
72746   }
72747 }
72748
72749
72750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72751   float jresult ;
72752   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72753   float arg2 ;
72754   float arg3 ;
72755   float result;
72756
72757   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72758   arg2 = (float)jarg2;
72759   arg3 = (float)jarg3;
72760   {
72761     try {
72762       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72763     } catch (std::out_of_range& e) {
72764       {
72765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (std::exception& e) {
72768       {
72769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72770       };
72771     } catch (...) {
72772       {
72773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72774       };
72775     }
72776   }
72777   jresult = result;
72778   return jresult;
72779 }
72780
72781
72782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72783   float jresult ;
72784   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72785   float arg2 ;
72786   float result;
72787
72788   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72789   arg2 = (float)jarg2;
72790   {
72791     try {
72792       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72793     } catch (std::out_of_range& e) {
72794       {
72795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72796       };
72797     } catch (std::exception& e) {
72798       {
72799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72800       };
72801     } catch (...) {
72802       {
72803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72804       };
72805     }
72806   }
72807   jresult = result;
72808   return jresult;
72809 }
72810
72811
72812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72813   float jresult ;
72814   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72815   unsigned int arg2 ;
72816   unsigned int *arg3 = 0 ;
72817   bool arg4 ;
72818   float result;
72819
72820   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72821   arg2 = (unsigned int)jarg2;
72822   arg3 = (unsigned int *)jarg3;
72823   arg4 = jarg4 ? true : false;
72824   {
72825     try {
72826       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72827     } catch (std::out_of_range& e) {
72828       {
72829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (std::exception& e) {
72832       {
72833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72834       };
72835     } catch (...) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72838       };
72839     }
72840   }
72841   jresult = result;
72842   return jresult;
72843 }
72844
72845
72846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72847   unsigned int jresult ;
72848   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72849   float arg2 ;
72850   bool arg3 ;
72851   unsigned int result;
72852
72853   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72854   arg2 = (float)jarg2;
72855   arg3 = jarg3 ? true : false;
72856   {
72857     try {
72858       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72859     } catch (std::out_of_range& e) {
72860       {
72861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72862       };
72863     } catch (std::exception& e) {
72864       {
72865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72866       };
72867     } catch (...) {
72868       {
72869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72870       };
72871     }
72872   }
72873   jresult = result;
72874   return jresult;
72875 }
72876
72877
72878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72879   unsigned int jresult ;
72880   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72881   unsigned int result;
72882
72883   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72884   {
72885     try {
72886       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72887     } catch (std::out_of_range& e) {
72888       {
72889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72890       };
72891     } catch (std::exception& e) {
72892       {
72893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (...) {
72896       {
72897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72898       };
72899     }
72900   }
72901   jresult = result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72907   int jresult ;
72908   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72909   Dali::Toolkit::Ruler::RulerType result;
72910
72911   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72912   {
72913     try {
72914       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72915     } catch (std::out_of_range& e) {
72916       {
72917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72918       };
72919     } catch (std::exception& e) {
72920       {
72921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (...) {
72924       {
72925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72926       };
72927     }
72928   }
72929   jresult = (int)result;
72930   return jresult;
72931 }
72932
72933
72934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72935   unsigned int jresult ;
72936   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72937   bool result;
72938
72939   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72940   {
72941     try {
72942       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72943     } catch (std::out_of_range& e) {
72944       {
72945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72946       };
72947     } catch (std::exception& e) {
72948       {
72949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72950       };
72951     } catch (...) {
72952       {
72953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72954       };
72955     }
72956   }
72957   jresult = result;
72958   return jresult;
72959 }
72960
72961
72962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72963   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72964
72965   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72966   {
72967     try {
72968       (arg1)->Enable();
72969     } catch (std::out_of_range& e) {
72970       {
72971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72972       };
72973     } catch (std::exception& e) {
72974       {
72975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72976       };
72977     } catch (...) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72980       };
72981     }
72982   }
72983 }
72984
72985
72986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72987   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72988
72989   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72990   {
72991     try {
72992       (arg1)->Disable();
72993     } catch (std::out_of_range& e) {
72994       {
72995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72996       };
72997     } catch (std::exception& e) {
72998       {
72999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73000       };
73001     } catch (...) {
73002       {
73003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73004       };
73005     }
73006   }
73007 }
73008
73009
73010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73011   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73012   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73013   Dali::Toolkit::RulerDomain *argp2 ;
73014
73015   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73016   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73017   if (!argp2) {
73018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73019     return ;
73020   }
73021   arg2 = *argp2;
73022   {
73023     try {
73024       (arg1)->SetDomain(arg2);
73025     } catch (std::out_of_range& e) {
73026       {
73027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73028       };
73029     } catch (std::exception& e) {
73030       {
73031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73032       };
73033     } catch (...) {
73034       {
73035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73036       };
73037     }
73038   }
73039 }
73040
73041
73042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73043   void * jresult ;
73044   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73045   Dali::Toolkit::RulerDomain *result = 0 ;
73046
73047   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73048   {
73049     try {
73050       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73051     } catch (std::out_of_range& e) {
73052       {
73053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73054       };
73055     } catch (std::exception& e) {
73056       {
73057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73058       };
73059     } catch (...) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73062       };
73063     }
73064   }
73065   jresult = (void *)result;
73066   return jresult;
73067 }
73068
73069
73070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73071   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73072
73073   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73074   {
73075     try {
73076       (arg1)->DisableDomain();
73077     } catch (std::out_of_range& e) {
73078       {
73079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73080       };
73081     } catch (std::exception& e) {
73082       {
73083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73084       };
73085     } catch (...) {
73086       {
73087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73088       };
73089     }
73090   }
73091 }
73092
73093
73094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73095   float jresult ;
73096   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73097   float arg2 ;
73098   float arg3 ;
73099   float arg4 ;
73100   float result;
73101
73102   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73103   arg2 = (float)jarg2;
73104   arg3 = (float)jarg3;
73105   arg4 = (float)jarg4;
73106   {
73107     try {
73108       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73109     } catch (std::out_of_range& e) {
73110       {
73111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73112       };
73113     } catch (std::exception& e) {
73114       {
73115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73116       };
73117     } catch (...) {
73118       {
73119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73120       };
73121     }
73122   }
73123   jresult = result;
73124   return jresult;
73125 }
73126
73127
73128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73129   float jresult ;
73130   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73131   float arg2 ;
73132   float arg3 ;
73133   float result;
73134
73135   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73136   arg2 = (float)jarg2;
73137   arg3 = (float)jarg3;
73138   {
73139     try {
73140       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73141     } catch (std::out_of_range& e) {
73142       {
73143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73144       };
73145     } catch (std::exception& e) {
73146       {
73147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73148       };
73149     } catch (...) {
73150       {
73151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73152       };
73153     }
73154   }
73155   jresult = result;
73156   return jresult;
73157 }
73158
73159
73160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73161   float jresult ;
73162   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73163   float arg2 ;
73164   float result;
73165
73166   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73167   arg2 = (float)jarg2;
73168   {
73169     try {
73170       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73171     } catch (std::out_of_range& e) {
73172       {
73173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73174       };
73175     } catch (std::exception& e) {
73176       {
73177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73178       };
73179     } catch (...) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73182       };
73183     }
73184   }
73185   jresult = result;
73186   return jresult;
73187 }
73188
73189
73190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73191   float jresult ;
73192   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73193   float arg2 ;
73194   float arg3 ;
73195   float arg4 ;
73196   Dali::Toolkit::ClampState *arg5 = 0 ;
73197   float result;
73198
73199   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73200   arg2 = (float)jarg2;
73201   arg3 = (float)jarg3;
73202   arg4 = (float)jarg4;
73203   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73204   if (!arg5) {
73205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73206     return 0;
73207   }
73208   {
73209     try {
73210       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73211     } catch (std::out_of_range& e) {
73212       {
73213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73214       };
73215     } catch (std::exception& e) {
73216       {
73217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73218       };
73219     } catch (...) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73222       };
73223     }
73224   }
73225   jresult = result;
73226   return jresult;
73227 }
73228
73229
73230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73231   float jresult ;
73232   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73233   float arg2 ;
73234   float arg3 ;
73235   float arg4 ;
73236   float arg5 ;
73237   float result;
73238
73239   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73240   arg2 = (float)jarg2;
73241   arg3 = (float)jarg3;
73242   arg4 = (float)jarg4;
73243   arg5 = (float)jarg5;
73244   {
73245     try {
73246       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (...) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73258       };
73259     }
73260   }
73261   jresult = result;
73262   return jresult;
73263 }
73264
73265
73266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73267   float jresult ;
73268   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73269   float arg2 ;
73270   float arg3 ;
73271   float arg4 ;
73272   float result;
73273
73274   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73275   arg2 = (float)jarg2;
73276   arg3 = (float)jarg3;
73277   arg4 = (float)jarg4;
73278   {
73279     try {
73280       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73281     } catch (std::out_of_range& e) {
73282       {
73283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73284       };
73285     } catch (std::exception& e) {
73286       {
73287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73288       };
73289     } catch (...) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73292       };
73293     }
73294   }
73295   jresult = result;
73296   return jresult;
73297 }
73298
73299
73300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73301   float jresult ;
73302   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73303   float arg2 ;
73304   float arg3 ;
73305   float result;
73306
73307   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73308   arg2 = (float)jarg2;
73309   arg3 = (float)jarg3;
73310   {
73311     try {
73312       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73313     } catch (std::out_of_range& e) {
73314       {
73315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73316       };
73317     } catch (std::exception& e) {
73318       {
73319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73320       };
73321     } catch (...) {
73322       {
73323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73324       };
73325     }
73326   }
73327   jresult = result;
73328   return jresult;
73329 }
73330
73331
73332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73333   float jresult ;
73334   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73335   float arg2 ;
73336   float result;
73337
73338   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73339   arg2 = (float)jarg2;
73340   {
73341     try {
73342       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (...) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73354       };
73355     }
73356   }
73357   jresult = result;
73358   return jresult;
73359 }
73360
73361
73362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73363   float jresult ;
73364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73365   float arg2 ;
73366   float arg3 ;
73367   float arg4 ;
73368   float arg5 ;
73369   Dali::Toolkit::ClampState *arg6 = 0 ;
73370   float result;
73371
73372   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73373   arg2 = (float)jarg2;
73374   arg3 = (float)jarg3;
73375   arg4 = (float)jarg4;
73376   arg5 = (float)jarg5;
73377   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73378   if (!arg6) {
73379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73380     return 0;
73381   }
73382   {
73383     try {
73384       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73385     } catch (std::out_of_range& e) {
73386       {
73387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73388       };
73389     } catch (std::exception& e) {
73390       {
73391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (...) {
73394       {
73395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73396       };
73397     }
73398   }
73399   jresult = result;
73400   return jresult;
73401 }
73402
73403
73404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73405   void * jresult ;
73406   Dali::Toolkit::DefaultRuler *result = 0 ;
73407
73408   {
73409     try {
73410       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73411     } catch (std::out_of_range& e) {
73412       {
73413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73414       };
73415     } catch (std::exception& e) {
73416       {
73417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73418       };
73419     } catch (...) {
73420       {
73421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73422       };
73423     }
73424   }
73425   jresult = (void *)result;
73426   return jresult;
73427 }
73428
73429
73430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73431   float jresult ;
73432   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73433   float arg2 ;
73434   float arg3 ;
73435   float result;
73436
73437   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73438   arg2 = (float)jarg2;
73439   arg3 = (float)jarg3;
73440   {
73441     try {
73442       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73443     } catch (std::out_of_range& e) {
73444       {
73445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73446       };
73447     } catch (std::exception& e) {
73448       {
73449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73450       };
73451     } catch (...) {
73452       {
73453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73454       };
73455     }
73456   }
73457   jresult = result;
73458   return jresult;
73459 }
73460
73461
73462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73463   float jresult ;
73464   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73465   unsigned int arg2 ;
73466   unsigned int *arg3 = 0 ;
73467   bool arg4 ;
73468   float result;
73469
73470   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73471   arg2 = (unsigned int)jarg2;
73472   arg3 = (unsigned int *)jarg3;
73473   arg4 = jarg4 ? true : false;
73474   {
73475     try {
73476       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73484       };
73485     } catch (...) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73488       };
73489     }
73490   }
73491   jresult = result;
73492   return jresult;
73493 }
73494
73495
73496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73497   unsigned int jresult ;
73498   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73499   float arg2 ;
73500   bool arg3 ;
73501   unsigned int result;
73502
73503   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73504   arg2 = (float)jarg2;
73505   arg3 = jarg3 ? true : false;
73506   {
73507     try {
73508       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73509     } catch (std::out_of_range& e) {
73510       {
73511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73512       };
73513     } catch (std::exception& e) {
73514       {
73515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73516       };
73517     } catch (...) {
73518       {
73519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73520       };
73521     }
73522   }
73523   jresult = result;
73524   return jresult;
73525 }
73526
73527
73528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73529   unsigned int jresult ;
73530   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73531   unsigned int result;
73532
73533   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73534   {
73535     try {
73536       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73537     } catch (std::out_of_range& e) {
73538       {
73539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73540       };
73541     } catch (std::exception& e) {
73542       {
73543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73544       };
73545     } catch (...) {
73546       {
73547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73548       };
73549     }
73550   }
73551   jresult = result;
73552   return jresult;
73553 }
73554
73555
73556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73557   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73558
73559   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73560   {
73561     try {
73562       delete arg1;
73563     } catch (std::out_of_range& e) {
73564       {
73565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73566       };
73567     } catch (std::exception& e) {
73568       {
73569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73570       };
73571     } catch (...) {
73572       {
73573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73574       };
73575     }
73576   }
73577 }
73578
73579
73580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73581   void * jresult ;
73582   float arg1 ;
73583   Dali::Toolkit::FixedRuler *result = 0 ;
73584
73585   arg1 = (float)jarg1;
73586   {
73587     try {
73588       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73589     } catch (std::out_of_range& e) {
73590       {
73591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73592       };
73593     } catch (std::exception& e) {
73594       {
73595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73596       };
73597     } catch (...) {
73598       {
73599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73600       };
73601     }
73602   }
73603   jresult = (void *)result;
73604   return jresult;
73605 }
73606
73607
73608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73609   void * jresult ;
73610   Dali::Toolkit::FixedRuler *result = 0 ;
73611
73612   {
73613     try {
73614       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73615     } catch (std::out_of_range& e) {
73616       {
73617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73618       };
73619     } catch (std::exception& e) {
73620       {
73621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (...) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73626       };
73627     }
73628   }
73629   jresult = (void *)result;
73630   return jresult;
73631 }
73632
73633
73634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73635   float jresult ;
73636   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73637   float arg2 ;
73638   float arg3 ;
73639   float result;
73640
73641   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73642   arg2 = (float)jarg2;
73643   arg3 = (float)jarg3;
73644   {
73645     try {
73646       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73647     } catch (std::out_of_range& e) {
73648       {
73649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73650       };
73651     } catch (std::exception& e) {
73652       {
73653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73654       };
73655     } catch (...) {
73656       {
73657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73658       };
73659     }
73660   }
73661   jresult = result;
73662   return jresult;
73663 }
73664
73665
73666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73667   float jresult ;
73668   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73669   unsigned int arg2 ;
73670   unsigned int *arg3 = 0 ;
73671   bool arg4 ;
73672   float result;
73673
73674   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73675   arg2 = (unsigned int)jarg2;
73676   arg3 = (unsigned int *)jarg3;
73677   arg4 = jarg4 ? true : false;
73678   {
73679     try {
73680       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73681     } catch (std::out_of_range& e) {
73682       {
73683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73684       };
73685     } catch (std::exception& e) {
73686       {
73687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73688       };
73689     } catch (...) {
73690       {
73691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73692       };
73693     }
73694   }
73695   jresult = result;
73696   return jresult;
73697 }
73698
73699
73700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73701   unsigned int jresult ;
73702   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73703   float arg2 ;
73704   bool arg3 ;
73705   unsigned int result;
73706
73707   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73708   arg2 = (float)jarg2;
73709   arg3 = jarg3 ? true : false;
73710   {
73711     try {
73712       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73713     } catch (std::out_of_range& e) {
73714       {
73715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73716       };
73717     } catch (std::exception& e) {
73718       {
73719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73720       };
73721     } catch (...) {
73722       {
73723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73724       };
73725     }
73726   }
73727   jresult = result;
73728   return jresult;
73729 }
73730
73731
73732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73733   unsigned int jresult ;
73734   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73735   unsigned int result;
73736
73737   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73738   {
73739     try {
73740       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73741     } catch (std::out_of_range& e) {
73742       {
73743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73744       };
73745     } catch (std::exception& e) {
73746       {
73747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73748       };
73749     } catch (...) {
73750       {
73751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73752       };
73753     }
73754   }
73755   jresult = result;
73756   return jresult;
73757 }
73758
73759
73760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73761   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73762
73763   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73764   {
73765     try {
73766       delete arg1;
73767     } catch (std::out_of_range& e) {
73768       {
73769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73770       };
73771     } catch (std::exception& e) {
73772       {
73773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73774       };
73775     } catch (...) {
73776       {
73777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73778       };
73779     }
73780   }
73781 }
73782
73783
73784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale = *arg2;
73791 }
73792
73793
73794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_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)->scale);
73801   jresult = (void *)result;
73802   return jresult;
73803 }
73804
73805
73806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73807   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73808   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73809
73810   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73811   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73812   if (arg1) (arg1)->position = *arg2;
73813 }
73814
73815
73816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73817   void * jresult ;
73818   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73819   Dali::Toolkit::ClampState2D *result = 0 ;
73820
73821   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73822   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73823   jresult = (void *)result;
73824   return jresult;
73825 }
73826
73827
73828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73829   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73830   Dali::Toolkit::ClampState arg2 ;
73831
73832   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73833   arg2 = (Dali::Toolkit::ClampState)jarg2;
73834   if (arg1) (arg1)->rotation = arg2;
73835 }
73836
73837
73838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73839   int jresult ;
73840   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73841   Dali::Toolkit::ClampState result;
73842
73843   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73844   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73845   jresult = (int)result;
73846   return jresult;
73847 }
73848
73849
73850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73851   void * jresult ;
73852   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73853
73854   {
73855     try {
73856       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73857     } catch (std::out_of_range& e) {
73858       {
73859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73860       };
73861     } catch (std::exception& e) {
73862       {
73863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73864       };
73865     } catch (...) {
73866       {
73867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73868       };
73869     }
73870   }
73871   jresult = (void *)result;
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73877   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73878
73879   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73880   {
73881     try {
73882       delete arg1;
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73890       };
73891     } catch (...) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73894       };
73895     }
73896   }
73897 }
73898
73899
73900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73901   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73902   Dali::Toolkit::SnapType arg2 ;
73903
73904   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73905   arg2 = (Dali::Toolkit::SnapType)jarg2;
73906   if (arg1) (arg1)->type = arg2;
73907 }
73908
73909
73910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73911   int jresult ;
73912   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73913   Dali::Toolkit::SnapType result;
73914
73915   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73916   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73917   jresult = (int)result;
73918   return jresult;
73919 }
73920
73921
73922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73923   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73924   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73925
73926   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73927   arg2 = (Dali::Vector2 *)jarg2;
73928   if (arg1) (arg1)->position = *arg2;
73929 }
73930
73931
73932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73933   void * jresult ;
73934   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73935   Dali::Vector2 *result = 0 ;
73936
73937   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73938   result = (Dali::Vector2 *)& ((arg1)->position);
73939   jresult = (void *)result;
73940   return jresult;
73941 }
73942
73943
73944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73945   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73946   float arg2 ;
73947
73948   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73949   arg2 = (float)jarg2;
73950   if (arg1) (arg1)->duration = arg2;
73951 }
73952
73953
73954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73955   float jresult ;
73956   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73957   float result;
73958
73959   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73960   result = (float) ((arg1)->duration);
73961   jresult = result;
73962   return jresult;
73963 }
73964
73965
73966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73967   void * jresult ;
73968   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73969
73970   {
73971     try {
73972       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73973     } catch (std::out_of_range& e) {
73974       {
73975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73976       };
73977     } catch (std::exception& e) {
73978       {
73979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73980       };
73981     } catch (...) {
73982       {
73983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73984       };
73985     }
73986   }
73987   jresult = (void *)result;
73988   return jresult;
73989 }
73990
73991
73992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73993   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73994
73995   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73996   {
73997     try {
73998       delete arg1;
73999     } catch (std::out_of_range& e) {
74000       {
74001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74002       };
74003     } catch (std::exception& e) {
74004       {
74005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74006       };
74007     } catch (...) {
74008       {
74009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74010       };
74011     }
74012   }
74013 }
74014
74015
74016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74017   int jresult ;
74018   int result;
74019
74020   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74021   jresult = (int)result;
74022   return jresult;
74023 }
74024
74025
74026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74027   int jresult ;
74028   int result;
74029
74030   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74031   jresult = (int)result;
74032   return jresult;
74033 }
74034
74035
74036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74037   int jresult ;
74038   int result;
74039
74040   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74041   jresult = (int)result;
74042   return jresult;
74043 }
74044
74045
74046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74047   int jresult ;
74048   int result;
74049
74050   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74051   jresult = (int)result;
74052   return jresult;
74053 }
74054
74055
74056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74057   int jresult ;
74058   int result;
74059
74060   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
74061   jresult = (int)result;
74062   return jresult;
74063 }
74064
74065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74066   int jresult ;
74067   int result;
74068
74069   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74070   jresult = (int)result;
74071   return jresult;
74072 }
74073
74074
74075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74076   int jresult ;
74077   int result;
74078
74079   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74080   jresult = (int)result;
74081   return jresult;
74082 }
74083
74084
74085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74086   int jresult ;
74087   int result;
74088
74089   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74090   jresult = (int)result;
74091   return jresult;
74092 }
74093
74094
74095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74096   int jresult ;
74097   int result;
74098
74099   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74100   jresult = (int)result;
74101   return jresult;
74102 }
74103
74104
74105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74106   int jresult ;
74107   int result;
74108
74109   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74110   jresult = (int)result;
74111   return jresult;
74112 }
74113
74114
74115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74116   int jresult ;
74117   int result;
74118
74119   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74120   jresult = (int)result;
74121   return jresult;
74122 }
74123
74124
74125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74126   int jresult ;
74127   int result;
74128
74129   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74130   jresult = (int)result;
74131   return jresult;
74132 }
74133
74134
74135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74136   int jresult ;
74137   int result;
74138
74139   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74140   jresult = (int)result;
74141   return jresult;
74142 }
74143
74144
74145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74146   int jresult ;
74147   int result;
74148
74149   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74150   jresult = (int)result;
74151   return jresult;
74152 }
74153
74154
74155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74156   int jresult ;
74157   int result;
74158
74159   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74160   jresult = (int)result;
74161   return jresult;
74162 }
74163
74164
74165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74166   int jresult ;
74167   int result;
74168
74169   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74170   jresult = (int)result;
74171   return jresult;
74172 }
74173
74174
74175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74176   int jresult ;
74177   int result;
74178
74179   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74180   jresult = (int)result;
74181   return jresult;
74182 }
74183
74184
74185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74186   int jresult ;
74187   int result;
74188
74189   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74190   jresult = (int)result;
74191   return jresult;
74192 }
74193
74194
74195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74196   int jresult ;
74197   int result;
74198
74199   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74200   jresult = (int)result;
74201   return jresult;
74202 }
74203
74204
74205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74206   int jresult ;
74207   int result;
74208
74209   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74210   jresult = (int)result;
74211   return jresult;
74212 }
74213
74214
74215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74216   int jresult ;
74217   int result;
74218
74219   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74220   jresult = (int)result;
74221   return jresult;
74222 }
74223
74224
74225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74226   int jresult ;
74227   int result;
74228
74229   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74230   jresult = (int)result;
74231   return jresult;
74232 }
74233
74234
74235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74236   int jresult ;
74237   int result;
74238
74239   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74240   jresult = (int)result;
74241   return jresult;
74242 }
74243
74244
74245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74246   int jresult ;
74247   int result;
74248
74249   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74250   jresult = (int)result;
74251   return jresult;
74252 }
74253
74254
74255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74256   int jresult ;
74257   int result;
74258
74259   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74260   jresult = (int)result;
74261   return jresult;
74262 }
74263
74264
74265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74266   int jresult ;
74267   int result;
74268
74269   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74270   jresult = (int)result;
74271   return jresult;
74272 }
74273
74274
74275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74276   void * jresult ;
74277   Dali::Toolkit::ScrollView::Property *result = 0 ;
74278
74279   {
74280     try {
74281       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74282     } catch (std::out_of_range& e) {
74283       {
74284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74285       };
74286     } catch (std::exception& e) {
74287       {
74288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74289       };
74290     } catch (...) {
74291       {
74292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74293       };
74294     }
74295   }
74296   jresult = (void *)result;
74297   return jresult;
74298 }
74299
74300
74301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74302   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74303
74304   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74305   {
74306     try {
74307       delete arg1;
74308     } catch (std::out_of_range& e) {
74309       {
74310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74311       };
74312     } catch (std::exception& e) {
74313       {
74314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74315       };
74316     } catch (...) {
74317       {
74318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74319       };
74320     }
74321   }
74322 }
74323
74324
74325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74326   void * jresult ;
74327   Dali::Toolkit::ScrollView *result = 0 ;
74328
74329   {
74330     try {
74331       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74332     } catch (std::out_of_range& e) {
74333       {
74334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74335       };
74336     } catch (std::exception& e) {
74337       {
74338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74339       };
74340     } catch (...) {
74341       {
74342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74343       };
74344     }
74345   }
74346   jresult = (void *)result;
74347   return jresult;
74348 }
74349
74350
74351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74352   void * jresult ;
74353   Dali::Toolkit::ScrollView *arg1 = 0 ;
74354   Dali::Toolkit::ScrollView *result = 0 ;
74355
74356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74357   if (!arg1) {
74358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74359     return 0;
74360   }
74361   {
74362     try {
74363       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74364     } catch (std::out_of_range& e) {
74365       {
74366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74367       };
74368     } catch (std::exception& e) {
74369       {
74370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74371       };
74372     } catch (...) {
74373       {
74374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74375       };
74376     }
74377   }
74378   jresult = (void *)result;
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74384   void * jresult ;
74385   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74386   Dali::Toolkit::ScrollView *arg2 = 0 ;
74387   Dali::Toolkit::ScrollView *result = 0 ;
74388
74389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74390   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74391   if (!arg2) {
74392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74393     return 0;
74394   }
74395   {
74396     try {
74397       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74398     } catch (std::out_of_range& e) {
74399       {
74400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74401       };
74402     } catch (std::exception& e) {
74403       {
74404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74405       };
74406     } catch (...) {
74407       {
74408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74409       };
74410     }
74411   }
74412   jresult = (void *)result;
74413   return jresult;
74414 }
74415
74416
74417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74418   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74419
74420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74421   {
74422     try {
74423       delete arg1;
74424     } catch (std::out_of_range& e) {
74425       {
74426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74427       };
74428     } catch (std::exception& e) {
74429       {
74430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74431       };
74432     } catch (...) {
74433       {
74434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74435       };
74436     }
74437   }
74438 }
74439
74440
74441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74442   void * jresult ;
74443   Dali::Toolkit::ScrollView result;
74444
74445   {
74446     try {
74447       result = Dali::Toolkit::ScrollView::New();
74448     } catch (std::out_of_range& e) {
74449       {
74450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74451       };
74452     } catch (std::exception& e) {
74453       {
74454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74455       };
74456     } catch (...) {
74457       {
74458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74459       };
74460     }
74461   }
74462   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74463   return jresult;
74464 }
74465
74466
74467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74468   void * jresult ;
74469   Dali::BaseHandle arg1 ;
74470   Dali::BaseHandle *argp1 ;
74471   Dali::Toolkit::ScrollView result;
74472
74473   argp1 = (Dali::BaseHandle *)jarg1;
74474   if (!argp1) {
74475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74476     return 0;
74477   }
74478   arg1 = *argp1;
74479   {
74480     try {
74481       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (...) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74493       };
74494     }
74495   }
74496   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74497   return jresult;
74498 }
74499
74500
74501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74502   void * jresult ;
74503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74504   Dali::AlphaFunction result;
74505
74506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74507   {
74508     try {
74509       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74510     } catch (std::out_of_range& e) {
74511       {
74512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74513       };
74514     } catch (std::exception& e) {
74515       {
74516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74517       };
74518     } catch (...) {
74519       {
74520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74521       };
74522     }
74523   }
74524   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74525   return jresult;
74526 }
74527
74528
74529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74531   Dali::AlphaFunction arg2 ;
74532   Dali::AlphaFunction *argp2 ;
74533
74534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74535   argp2 = (Dali::AlphaFunction *)jarg2;
74536   if (!argp2) {
74537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74538     return ;
74539   }
74540   arg2 = *argp2;
74541   {
74542     try {
74543       (arg1)->SetScrollSnapAlphaFunction(arg2);
74544     } catch (std::out_of_range& e) {
74545       {
74546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74547       };
74548     } catch (std::exception& e) {
74549       {
74550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74551       };
74552     } catch (...) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74555       };
74556     }
74557   }
74558 }
74559
74560
74561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74562   void * jresult ;
74563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74564   Dali::AlphaFunction result;
74565
74566   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74567   {
74568     try {
74569       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74570     } catch (std::out_of_range& e) {
74571       {
74572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74573       };
74574     } catch (std::exception& e) {
74575       {
74576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74577       };
74578     } catch (...) {
74579       {
74580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74581       };
74582     }
74583   }
74584   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74585   return jresult;
74586 }
74587
74588
74589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74590   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74591   Dali::AlphaFunction arg2 ;
74592   Dali::AlphaFunction *argp2 ;
74593
74594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74595   argp2 = (Dali::AlphaFunction *)jarg2;
74596   if (!argp2) {
74597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74598     return ;
74599   }
74600   arg2 = *argp2;
74601   {
74602     try {
74603       (arg1)->SetScrollFlickAlphaFunction(arg2);
74604     } catch (std::out_of_range& e) {
74605       {
74606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74607       };
74608     } catch (std::exception& e) {
74609       {
74610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74611       };
74612     } catch (...) {
74613       {
74614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74615       };
74616     }
74617   }
74618 }
74619
74620
74621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74622   float jresult ;
74623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74624   float result;
74625
74626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74627   {
74628     try {
74629       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74630     } catch (std::out_of_range& e) {
74631       {
74632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74633       };
74634     } catch (std::exception& e) {
74635       {
74636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74637       };
74638     } catch (...) {
74639       {
74640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74641       };
74642     }
74643   }
74644   jresult = result;
74645   return jresult;
74646 }
74647
74648
74649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74651   float arg2 ;
74652
74653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74654   arg2 = (float)jarg2;
74655   {
74656     try {
74657       (arg1)->SetScrollSnapDuration(arg2);
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74665       };
74666     } catch (...) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74669       };
74670     }
74671   }
74672 }
74673
74674
74675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74676   float jresult ;
74677   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74678   float result;
74679
74680   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74681   {
74682     try {
74683       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74684     } catch (std::out_of_range& e) {
74685       {
74686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74687       };
74688     } catch (std::exception& e) {
74689       {
74690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74691       };
74692     } catch (...) {
74693       {
74694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74695       };
74696     }
74697   }
74698   jresult = result;
74699   return jresult;
74700 }
74701
74702
74703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74704   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74705   float arg2 ;
74706
74707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74708   arg2 = (float)jarg2;
74709   {
74710     try {
74711       (arg1)->SetScrollFlickDuration(arg2);
74712     } catch (std::out_of_range& e) {
74713       {
74714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74715       };
74716     } catch (std::exception& e) {
74717       {
74718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74719       };
74720     } catch (...) {
74721       {
74722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74723       };
74724     }
74725   }
74726 }
74727
74728
74729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74730   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74731   Dali::Toolkit::RulerPtr arg2 ;
74732   Dali::Toolkit::RulerPtr *argp2 ;
74733
74734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74735   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74736   if (!argp2) {
74737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74738     return ;
74739   }
74740   arg2 = *argp2;
74741   {
74742     try {
74743       (arg1)->SetRulerX(arg2);
74744     } catch (std::out_of_range& e) {
74745       {
74746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74747       };
74748     } catch (std::exception& e) {
74749       {
74750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74751       };
74752     } catch (...) {
74753       {
74754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74755       };
74756     }
74757   }
74758 }
74759
74760
74761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74763   Dali::Toolkit::RulerPtr arg2 ;
74764   Dali::Toolkit::RulerPtr *argp2 ;
74765
74766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74767   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74768   if (!argp2) {
74769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74770     return ;
74771   }
74772   arg2 = *argp2;
74773   {
74774     try {
74775       (arg1)->SetRulerY(arg2);
74776     } catch (std::out_of_range& e) {
74777       {
74778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74779       };
74780     } catch (std::exception& e) {
74781       {
74782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74783       };
74784     } catch (...) {
74785       {
74786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74787       };
74788     }
74789   }
74790 }
74791
74792
74793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74794   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74795   bool arg2 ;
74796
74797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74798   arg2 = jarg2 ? true : false;
74799   {
74800     try {
74801       (arg1)->SetScrollSensitive(arg2);
74802     } catch (std::out_of_range& e) {
74803       {
74804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74805       };
74806     } catch (std::exception& e) {
74807       {
74808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74809       };
74810     } catch (...) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74813       };
74814     }
74815   }
74816 }
74817
74818
74819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74821   float arg2 ;
74822   float arg3 ;
74823
74824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74825   arg2 = (float)jarg2;
74826   arg3 = (float)jarg3;
74827   {
74828     try {
74829       (arg1)->SetMaxOvershoot(arg2,arg3);
74830     } catch (std::out_of_range& e) {
74831       {
74832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74833       };
74834     } catch (std::exception& e) {
74835       {
74836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74837       };
74838     } catch (...) {
74839       {
74840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74841       };
74842     }
74843   }
74844 }
74845
74846
74847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74849   Dali::AlphaFunction arg2 ;
74850   Dali::AlphaFunction *argp2 ;
74851
74852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74853   argp2 = (Dali::AlphaFunction *)jarg2;
74854   if (!argp2) {
74855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74856     return ;
74857   }
74858   arg2 = *argp2;
74859   {
74860     try {
74861       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74862     } catch (std::out_of_range& e) {
74863       {
74864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74865       };
74866     } catch (std::exception& e) {
74867       {
74868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74869       };
74870     } catch (...) {
74871       {
74872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74873       };
74874     }
74875   }
74876 }
74877
74878
74879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74880   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74881   float arg2 ;
74882
74883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74884   arg2 = (float)jarg2;
74885   {
74886     try {
74887       (arg1)->SetSnapOvershootDuration(arg2);
74888     } catch (std::out_of_range& e) {
74889       {
74890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74891       };
74892     } catch (std::exception& e) {
74893       {
74894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74895       };
74896     } catch (...) {
74897       {
74898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74899       };
74900     }
74901   }
74902 }
74903
74904
74905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74907   bool arg2 ;
74908
74909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74910   arg2 = jarg2 ? true : false;
74911   {
74912     try {
74913       (arg1)->SetActorAutoSnap(arg2);
74914     } catch (std::out_of_range& e) {
74915       {
74916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74917       };
74918     } catch (std::exception& e) {
74919       {
74920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74921       };
74922     } catch (...) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74925       };
74926     }
74927   }
74928 }
74929
74930
74931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74933   bool arg2 ;
74934
74935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74936   arg2 = jarg2 ? true : false;
74937   {
74938     try {
74939       (arg1)->SetWrapMode(arg2);
74940     } catch (std::out_of_range& e) {
74941       {
74942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74943       };
74944     } catch (std::exception& e) {
74945       {
74946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74947       };
74948     } catch (...) {
74949       {
74950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74951       };
74952     }
74953   }
74954 }
74955
74956
74957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74958   int jresult ;
74959   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74960   int result;
74961
74962   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74963   {
74964     try {
74965       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74966     } catch (std::out_of_range& e) {
74967       {
74968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74969       };
74970     } catch (std::exception& e) {
74971       {
74972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74973       };
74974     } catch (...) {
74975       {
74976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74977       };
74978     }
74979   }
74980   jresult = result;
74981   return jresult;
74982 }
74983
74984
74985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74987   int arg2 ;
74988
74989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74990   arg2 = (int)jarg2;
74991   {
74992     try {
74993       (arg1)->SetScrollUpdateDistance(arg2);
74994     } catch (std::out_of_range& e) {
74995       {
74996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74997       };
74998     } catch (std::exception& e) {
74999       {
75000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75001       };
75002     } catch (...) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75005       };
75006     }
75007   }
75008 }
75009
75010
75011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75012   unsigned int jresult ;
75013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75014   bool result;
75015
75016   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75017   {
75018     try {
75019       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75020     } catch (std::out_of_range& e) {
75021       {
75022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75023       };
75024     } catch (std::exception& e) {
75025       {
75026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75027       };
75028     } catch (...) {
75029       {
75030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75031       };
75032     }
75033   }
75034   jresult = result;
75035   return jresult;
75036 }
75037
75038
75039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75040   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75041   bool arg2 ;
75042
75043   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75044   arg2 = jarg2 ? true : false;
75045   {
75046     try {
75047       (arg1)->SetAxisAutoLock(arg2);
75048     } catch (std::out_of_range& e) {
75049       {
75050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75051       };
75052     } catch (std::exception& e) {
75053       {
75054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75055       };
75056     } catch (...) {
75057       {
75058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75059       };
75060     }
75061   }
75062 }
75063
75064
75065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75066   float jresult ;
75067   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75068   float result;
75069
75070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75071   {
75072     try {
75073       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75074     } catch (std::out_of_range& e) {
75075       {
75076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75077       };
75078     } catch (std::exception& e) {
75079       {
75080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75081       };
75082     } catch (...) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75085       };
75086     }
75087   }
75088   jresult = result;
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75094   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75095   float arg2 ;
75096
75097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75098   arg2 = (float)jarg2;
75099   {
75100     try {
75101       (arg1)->SetAxisAutoLockGradient(arg2);
75102     } catch (std::out_of_range& e) {
75103       {
75104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75105       };
75106     } catch (std::exception& e) {
75107       {
75108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75109       };
75110     } catch (...) {
75111       {
75112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75113       };
75114     }
75115   }
75116 }
75117
75118
75119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75120   float jresult ;
75121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75122   float result;
75123
75124   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75125   {
75126     try {
75127       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75128     } catch (std::out_of_range& e) {
75129       {
75130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75131       };
75132     } catch (std::exception& e) {
75133       {
75134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75135       };
75136     } catch (...) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75139       };
75140     }
75141   }
75142   jresult = result;
75143   return jresult;
75144 }
75145
75146
75147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75149   float arg2 ;
75150
75151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75152   arg2 = (float)jarg2;
75153   {
75154     try {
75155       (arg1)->SetFrictionCoefficient(arg2);
75156     } catch (std::out_of_range& e) {
75157       {
75158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75159       };
75160     } catch (std::exception& e) {
75161       {
75162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75167       };
75168     }
75169   }
75170 }
75171
75172
75173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75174   float jresult ;
75175   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75176   float result;
75177
75178   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75179   {
75180     try {
75181       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75182     } catch (std::out_of_range& e) {
75183       {
75184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75185       };
75186     } catch (std::exception& e) {
75187       {
75188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75189       };
75190     } catch (...) {
75191       {
75192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75193       };
75194     }
75195   }
75196   jresult = result;
75197   return jresult;
75198 }
75199
75200
75201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75203   float arg2 ;
75204
75205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75206   arg2 = (float)jarg2;
75207   {
75208     try {
75209       (arg1)->SetFlickSpeedCoefficient(arg2);
75210     } catch (std::out_of_range& e) {
75211       {
75212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75213       };
75214     } catch (std::exception& e) {
75215       {
75216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75217       };
75218     } catch (...) {
75219       {
75220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75221       };
75222     }
75223   }
75224 }
75225
75226
75227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75228   void * jresult ;
75229   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75230   Dali::Vector2 result;
75231
75232   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75233   {
75234     try {
75235       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75236     } catch (std::out_of_range& e) {
75237       {
75238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75239       };
75240     } catch (std::exception& e) {
75241       {
75242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75243       };
75244     } catch (...) {
75245       {
75246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75247       };
75248     }
75249   }
75250   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75251   return jresult;
75252 }
75253
75254
75255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75257   Dali::Vector2 *arg2 = 0 ;
75258
75259   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75260   arg2 = (Dali::Vector2 *)jarg2;
75261   if (!arg2) {
75262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75263     return ;
75264   }
75265   {
75266     try {
75267       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75268     } catch (std::out_of_range& e) {
75269       {
75270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75271       };
75272     } catch (std::exception& e) {
75273       {
75274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75275       };
75276     } catch (...) {
75277       {
75278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75279       };
75280     }
75281   }
75282 }
75283
75284
75285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75286   float jresult ;
75287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75288   float result;
75289
75290   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75291   {
75292     try {
75293       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75294     } catch (std::out_of_range& e) {
75295       {
75296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75297       };
75298     } catch (std::exception& e) {
75299       {
75300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75301       };
75302     } catch (...) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75305       };
75306     }
75307   }
75308   jresult = result;
75309   return jresult;
75310 }
75311
75312
75313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75314   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75315   float arg2 ;
75316
75317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75318   arg2 = (float)jarg2;
75319   {
75320     try {
75321       (arg1)->SetMinimumSpeedForFlick(arg2);
75322     } catch (std::out_of_range& e) {
75323       {
75324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75325       };
75326     } catch (std::exception& e) {
75327       {
75328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75329       };
75330     } catch (...) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75333       };
75334     }
75335   }
75336 }
75337
75338
75339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75340   float jresult ;
75341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75342   float result;
75343
75344   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75345   {
75346     try {
75347       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75348     } catch (std::out_of_range& e) {
75349       {
75350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75351       };
75352     } catch (std::exception& e) {
75353       {
75354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75355       };
75356     } catch (...) {
75357       {
75358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75359       };
75360     }
75361   }
75362   jresult = result;
75363   return jresult;
75364 }
75365
75366
75367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75369   float arg2 ;
75370
75371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75372   arg2 = (float)jarg2;
75373   {
75374     try {
75375       (arg1)->SetMaxFlickSpeed(arg2);
75376     } catch (std::out_of_range& e) {
75377       {
75378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75379       };
75380     } catch (std::exception& e) {
75381       {
75382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75383       };
75384     } catch (...) {
75385       {
75386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75387       };
75388     }
75389   }
75390 }
75391
75392
75393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75394   void * jresult ;
75395   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75396   Dali::Vector2 result;
75397
75398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75399   {
75400     try {
75401       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75402     } catch (std::out_of_range& e) {
75403       {
75404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75405       };
75406     } catch (std::exception& e) {
75407       {
75408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75409       };
75410     } catch (...) {
75411       {
75412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75413       };
75414     }
75415   }
75416   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75417   return jresult;
75418 }
75419
75420
75421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75423   Dali::Vector2 arg2 ;
75424   Dali::Vector2 *argp2 ;
75425
75426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75427   argp2 = (Dali::Vector2 *)jarg2;
75428   if (!argp2) {
75429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75430     return ;
75431   }
75432   arg2 = *argp2;
75433   {
75434     try {
75435       (arg1)->SetWheelScrollDistanceStep(arg2);
75436     } catch (std::out_of_range& e) {
75437       {
75438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75439       };
75440     } catch (std::exception& e) {
75441       {
75442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75443       };
75444     } catch (...) {
75445       {
75446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75447       };
75448     }
75449   }
75450 }
75451
75452
75453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75454   void * jresult ;
75455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75456   Dali::Vector2 result;
75457
75458   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75459   {
75460     try {
75461       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75462     } catch (std::out_of_range& e) {
75463       {
75464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75465       };
75466     } catch (std::exception& e) {
75467       {
75468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75469       };
75470     } catch (...) {
75471       {
75472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75473       };
75474     }
75475   }
75476   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75477   return jresult;
75478 }
75479
75480
75481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75482   unsigned int jresult ;
75483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75484   unsigned int result;
75485
75486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75487   {
75488     try {
75489       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75490     } catch (std::out_of_range& e) {
75491       {
75492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75493       };
75494     } catch (std::exception& e) {
75495       {
75496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75497       };
75498     } catch (...) {
75499       {
75500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75501       };
75502     }
75503   }
75504   jresult = result;
75505   return jresult;
75506 }
75507
75508
75509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75510   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75511   Dali::Vector2 *arg2 = 0 ;
75512
75513   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75514   arg2 = (Dali::Vector2 *)jarg2;
75515   if (!arg2) {
75516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75517     return ;
75518   }
75519   {
75520     try {
75521       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75522     } catch (std::out_of_range& e) {
75523       {
75524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75525       };
75526     } catch (std::exception& e) {
75527       {
75528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75529       };
75530     } catch (...) {
75531       {
75532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75533       };
75534     }
75535   }
75536 }
75537
75538
75539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75541   Dali::Vector2 *arg2 = 0 ;
75542   float arg3 ;
75543
75544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75545   arg2 = (Dali::Vector2 *)jarg2;
75546   if (!arg2) {
75547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75548     return ;
75549   }
75550   arg3 = (float)jarg3;
75551   {
75552     try {
75553       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75554     } catch (std::out_of_range& e) {
75555       {
75556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75557       };
75558     } catch (std::exception& e) {
75559       {
75560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75561       };
75562     } catch (...) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75565       };
75566     }
75567   }
75568 }
75569
75570
75571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75573   Dali::Vector2 *arg2 = 0 ;
75574   float arg3 ;
75575   Dali::AlphaFunction arg4 ;
75576   Dali::AlphaFunction *argp4 ;
75577
75578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75579   arg2 = (Dali::Vector2 *)jarg2;
75580   if (!arg2) {
75581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75582     return ;
75583   }
75584   arg3 = (float)jarg3;
75585   argp4 = (Dali::AlphaFunction *)jarg4;
75586   if (!argp4) {
75587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75588     return ;
75589   }
75590   arg4 = *argp4;
75591   {
75592     try {
75593       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75594     } catch (std::out_of_range& e) {
75595       {
75596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75597       };
75598     } catch (std::exception& e) {
75599       {
75600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75601       };
75602     } catch (...) {
75603       {
75604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75605       };
75606     }
75607   }
75608 }
75609
75610
75611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75612   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75613   Dali::Vector2 *arg2 = 0 ;
75614   float arg3 ;
75615   Dali::Toolkit::DirectionBias arg4 ;
75616   Dali::Toolkit::DirectionBias arg5 ;
75617
75618   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75619   arg2 = (Dali::Vector2 *)jarg2;
75620   if (!arg2) {
75621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75622     return ;
75623   }
75624   arg3 = (float)jarg3;
75625   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75626   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75627   {
75628     try {
75629       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75630     } catch (std::out_of_range& e) {
75631       {
75632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75633       };
75634     } catch (std::exception& e) {
75635       {
75636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75637       };
75638     } catch (...) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75641       };
75642     }
75643   }
75644 }
75645
75646
75647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75649   Dali::Vector2 *arg2 = 0 ;
75650   float arg3 ;
75651   Dali::AlphaFunction arg4 ;
75652   Dali::Toolkit::DirectionBias arg5 ;
75653   Dali::Toolkit::DirectionBias arg6 ;
75654   Dali::AlphaFunction *argp4 ;
75655
75656   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75657   arg2 = (Dali::Vector2 *)jarg2;
75658   if (!arg2) {
75659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75660     return ;
75661   }
75662   arg3 = (float)jarg3;
75663   argp4 = (Dali::AlphaFunction *)jarg4;
75664   if (!argp4) {
75665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75666     return ;
75667   }
75668   arg4 = *argp4;
75669   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75670   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75671   {
75672     try {
75673       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75674     } catch (std::out_of_range& e) {
75675       {
75676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75677       };
75678     } catch (std::exception& e) {
75679       {
75680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75681       };
75682     } catch (...) {
75683       {
75684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75685       };
75686     }
75687   }
75688 }
75689
75690
75691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75693   unsigned int arg2 ;
75694
75695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75696   arg2 = (unsigned int)jarg2;
75697   {
75698     try {
75699       (arg1)->ScrollTo(arg2);
75700     } catch (std::out_of_range& e) {
75701       {
75702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75703       };
75704     } catch (std::exception& e) {
75705       {
75706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75707       };
75708     } catch (...) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75711       };
75712     }
75713   }
75714 }
75715
75716
75717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75719   unsigned int arg2 ;
75720   float arg3 ;
75721
75722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75723   arg2 = (unsigned int)jarg2;
75724   arg3 = (float)jarg3;
75725   {
75726     try {
75727       (arg1)->ScrollTo(arg2,arg3);
75728     } catch (std::out_of_range& e) {
75729       {
75730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75731       };
75732     } catch (std::exception& e) {
75733       {
75734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75735       };
75736     } catch (...) {
75737       {
75738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75739       };
75740     }
75741   }
75742 }
75743
75744
75745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75747   unsigned int arg2 ;
75748   float arg3 ;
75749   Dali::Toolkit::DirectionBias arg4 ;
75750
75751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75752   arg2 = (unsigned int)jarg2;
75753   arg3 = (float)jarg3;
75754   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75755   {
75756     try {
75757       (arg1)->ScrollTo(arg2,arg3,arg4);
75758     } catch (std::out_of_range& e) {
75759       {
75760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75761       };
75762     } catch (std::exception& e) {
75763       {
75764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75765       };
75766     } catch (...) {
75767       {
75768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75769       };
75770     }
75771   }
75772 }
75773
75774
75775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75776   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75777   Dali::Actor *arg2 = 0 ;
75778
75779   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75780   arg2 = (Dali::Actor *)jarg2;
75781   if (!arg2) {
75782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75783     return ;
75784   }
75785   {
75786     try {
75787       (arg1)->ScrollTo(*arg2);
75788     } catch (std::out_of_range& e) {
75789       {
75790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75791       };
75792     } catch (std::exception& e) {
75793       {
75794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75795       };
75796     } catch (...) {
75797       {
75798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75799       };
75800     }
75801   }
75802 }
75803
75804
75805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75807   Dali::Actor *arg2 = 0 ;
75808   float arg3 ;
75809
75810   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75811   arg2 = (Dali::Actor *)jarg2;
75812   if (!arg2) {
75813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75814     return ;
75815   }
75816   arg3 = (float)jarg3;
75817   {
75818     try {
75819       (arg1)->ScrollTo(*arg2,arg3);
75820     } catch (std::out_of_range& e) {
75821       {
75822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75823       };
75824     } catch (std::exception& e) {
75825       {
75826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75827       };
75828     } catch (...) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75831       };
75832     }
75833   }
75834 }
75835
75836
75837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75838   unsigned int jresult ;
75839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75840   bool result;
75841
75842   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75843   {
75844     try {
75845       result = (bool)(arg1)->ScrollToSnapPoint();
75846     } catch (std::out_of_range& e) {
75847       {
75848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (std::exception& e) {
75851       {
75852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75857       };
75858     }
75859   }
75860   jresult = result;
75861   return jresult;
75862 }
75863
75864
75865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75866   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75867   Dali::Constraint arg2 ;
75868   Dali::Constraint *argp2 ;
75869
75870   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75871   argp2 = (Dali::Constraint *)jarg2;
75872   if (!argp2) {
75873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75874     return ;
75875   }
75876   arg2 = *argp2;
75877   {
75878     try {
75879       (arg1)->ApplyConstraintToChildren(arg2);
75880     } catch (std::out_of_range& e) {
75881       {
75882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75883       };
75884     } catch (std::exception& e) {
75885       {
75886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75887       };
75888     } catch (...) {
75889       {
75890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75891       };
75892     }
75893   }
75894 }
75895
75896
75897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75898   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75899
75900   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75901   {
75902     try {
75903       (arg1)->RemoveConstraintsFromChildren();
75904     } catch (std::out_of_range& e) {
75905       {
75906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75907       };
75908     } catch (std::exception& e) {
75909       {
75910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75911       };
75912     } catch (...) {
75913       {
75914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75915       };
75916     }
75917   }
75918 }
75919
75920
75921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75923   Dali::Toolkit::ScrollViewEffect arg2 ;
75924   Dali::Toolkit::ScrollViewEffect *argp2 ;
75925
75926   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75927   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75928   if (!argp2) {
75929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75930     return ;
75931   }
75932   arg2 = *argp2;
75933   {
75934     try {
75935       (arg1)->ApplyEffect(arg2);
75936     } catch (std::out_of_range& e) {
75937       {
75938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75939       };
75940     } catch (std::exception& e) {
75941       {
75942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75947       };
75948     }
75949   }
75950 }
75951
75952
75953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75954   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75955   Dali::Toolkit::ScrollViewEffect arg2 ;
75956   Dali::Toolkit::ScrollViewEffect *argp2 ;
75957
75958   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75959   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75960   if (!argp2) {
75961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75962     return ;
75963   }
75964   arg2 = *argp2;
75965   {
75966     try {
75967       (arg1)->RemoveEffect(arg2);
75968     } catch (std::out_of_range& e) {
75969       {
75970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75971       };
75972     } catch (std::exception& e) {
75973       {
75974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75975       };
75976     } catch (...) {
75977       {
75978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75979       };
75980     }
75981   }
75982 }
75983
75984
75985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75987
75988   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75989   {
75990     try {
75991       (arg1)->RemoveAllEffects();
75992     } catch (std::out_of_range& e) {
75993       {
75994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75995       };
75996     } catch (std::exception& e) {
75997       {
75998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75999       };
76000     } catch (...) {
76001       {
76002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76003       };
76004     }
76005   }
76006 }
76007
76008
76009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76011   Dali::Actor arg2 ;
76012   Dali::Actor *argp2 ;
76013
76014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76015   argp2 = (Dali::Actor *)jarg2;
76016   if (!argp2) {
76017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76018     return ;
76019   }
76020   arg2 = *argp2;
76021   {
76022     try {
76023       (arg1)->BindActor(arg2);
76024     } catch (std::out_of_range& e) {
76025       {
76026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76027       };
76028     } catch (std::exception& e) {
76029       {
76030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76031       };
76032     } catch (...) {
76033       {
76034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76035       };
76036     }
76037   }
76038 }
76039
76040
76041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76043   Dali::Actor arg2 ;
76044   Dali::Actor *argp2 ;
76045
76046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76047   argp2 = (Dali::Actor *)jarg2;
76048   if (!argp2) {
76049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76050     return ;
76051   }
76052   arg2 = *argp2;
76053   {
76054     try {
76055       (arg1)->UnbindActor(arg2);
76056     } catch (std::out_of_range& e) {
76057       {
76058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76059       };
76060     } catch (std::exception& e) {
76061       {
76062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76063       };
76064     } catch (...) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76067       };
76068     }
76069   }
76070 }
76071
76072
76073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76075   Dali::Radian arg2 ;
76076   Dali::Radian arg3 ;
76077   Dali::Radian *argp2 ;
76078   Dali::Radian *argp3 ;
76079
76080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76081   argp2 = (Dali::Radian *)jarg2;
76082   if (!argp2) {
76083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76084     return ;
76085   }
76086   arg2 = *argp2;
76087   argp3 = (Dali::Radian *)jarg3;
76088   if (!argp3) {
76089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76090     return ;
76091   }
76092   arg3 = *argp3;
76093   {
76094     try {
76095       (arg1)->SetScrollingDirection(arg2,arg3);
76096     } catch (std::out_of_range& e) {
76097       {
76098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (std::exception& e) {
76101       {
76102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (...) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76107       };
76108     }
76109   }
76110 }
76111
76112
76113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76115   Dali::Radian arg2 ;
76116   Dali::Radian *argp2 ;
76117
76118   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76119   argp2 = (Dali::Radian *)jarg2;
76120   if (!argp2) {
76121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76122     return ;
76123   }
76124   arg2 = *argp2;
76125   {
76126     try {
76127       (arg1)->SetScrollingDirection(arg2);
76128     } catch (std::out_of_range& e) {
76129       {
76130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76131       };
76132     } catch (std::exception& e) {
76133       {
76134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76135       };
76136     } catch (...) {
76137       {
76138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76139       };
76140     }
76141   }
76142 }
76143
76144
76145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76147   Dali::Radian arg2 ;
76148   Dali::Radian *argp2 ;
76149
76150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76151   argp2 = (Dali::Radian *)jarg2;
76152   if (!argp2) {
76153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76154     return ;
76155   }
76156   arg2 = *argp2;
76157   {
76158     try {
76159       (arg1)->RemoveScrollingDirection(arg2);
76160     } catch (std::out_of_range& e) {
76161       {
76162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (std::exception& e) {
76165       {
76166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76167       };
76168     } catch (...) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76171       };
76172     }
76173   }
76174 }
76175
76176
76177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76178   void * jresult ;
76179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76180   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76181
76182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76183   {
76184     try {
76185       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76186     } catch (std::out_of_range& e) {
76187       {
76188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76189       };
76190     } catch (std::exception& e) {
76191       {
76192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76193       };
76194     } catch (...) {
76195       {
76196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76197       };
76198     }
76199   }
76200   jresult = (void *)result;
76201   return jresult;
76202 }
76203
76204
76205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76206   int jresult ;
76207   int result;
76208
76209   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76210   jresult = (int)result;
76211   return jresult;
76212 }
76213
76214
76215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76216   int jresult ;
76217   int result;
76218
76219   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76220   jresult = (int)result;
76221   return jresult;
76222 }
76223
76224
76225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76226   int jresult ;
76227   int result;
76228
76229   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76230   jresult = (int)result;
76231   return jresult;
76232 }
76233
76234
76235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76236   int jresult ;
76237   int result;
76238
76239   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76240   jresult = (int)result;
76241   return jresult;
76242 }
76243
76244
76245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76246   int jresult ;
76247   int result;
76248
76249   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76250   jresult = (int)result;
76251   return jresult;
76252 }
76253
76254
76255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76256   void * jresult ;
76257   Dali::Toolkit::TableView::Property *result = 0 ;
76258
76259   {
76260     try {
76261       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76262     } catch (std::out_of_range& e) {
76263       {
76264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76265       };
76266     } catch (std::exception& e) {
76267       {
76268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76269       };
76270     } catch (...) {
76271       {
76272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76273       };
76274     }
76275   }
76276   jresult = (void *)result;
76277   return jresult;
76278 }
76279
76280
76281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76282   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76283
76284   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76285   {
76286     try {
76287       delete arg1;
76288     } catch (std::out_of_range& e) {
76289       {
76290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76291       };
76292     } catch (std::exception& e) {
76293       {
76294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (...) {
76297       {
76298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76299       };
76300     }
76301   }
76302 }
76303
76304
76305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76306   int jresult ;
76307   int result;
76308
76309   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76310   jresult = (int)result;
76311   return jresult;
76312 }
76313
76314
76315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76316   int jresult ;
76317   int result;
76318
76319   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76320   jresult = (int)result;
76321   return jresult;
76322 }
76323
76324
76325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76326   int jresult ;
76327   int result;
76328
76329   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76330   jresult = (int)result;
76331   return jresult;
76332 }
76333
76334
76335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76336   int jresult ;
76337   int result;
76338
76339   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76340   jresult = (int)result;
76341   return jresult;
76342 }
76343
76344
76345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76346   int jresult ;
76347   int result;
76348
76349   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76350   jresult = (int)result;
76351   return jresult;
76352 }
76353
76354
76355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76356   void * jresult ;
76357   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76358
76359   {
76360     try {
76361       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76362     } catch (std::out_of_range& e) {
76363       {
76364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76365       };
76366     } catch (std::exception& e) {
76367       {
76368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76369       };
76370     } catch (...) {
76371       {
76372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76373       };
76374     }
76375   }
76376   jresult = (void *)result;
76377   return jresult;
76378 }
76379
76380
76381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76382   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76383
76384   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76385   {
76386     try {
76387       delete arg1;
76388     } catch (std::out_of_range& e) {
76389       {
76390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76391       };
76392     } catch (std::exception& e) {
76393       {
76394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76395       };
76396     } catch (...) {
76397       {
76398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76399       };
76400     }
76401   }
76402 }
76403
76404
76405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76406   void * jresult ;
76407   unsigned int arg1 ;
76408   unsigned int arg2 ;
76409   unsigned int arg3 ;
76410   unsigned int arg4 ;
76411   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76412
76413   arg1 = (unsigned int)jarg1;
76414   arg2 = (unsigned int)jarg2;
76415   arg3 = (unsigned int)jarg3;
76416   arg4 = (unsigned int)jarg4;
76417   {
76418     try {
76419       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76420     } catch (std::out_of_range& e) {
76421       {
76422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76423       };
76424     } catch (std::exception& e) {
76425       {
76426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76427       };
76428     } catch (...) {
76429       {
76430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76431       };
76432     }
76433   }
76434   jresult = (void *)result;
76435   return jresult;
76436 }
76437
76438
76439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76440   void * jresult ;
76441   unsigned int arg1 ;
76442   unsigned int arg2 ;
76443   unsigned int arg3 ;
76444   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76445
76446   arg1 = (unsigned int)jarg1;
76447   arg2 = (unsigned int)jarg2;
76448   arg3 = (unsigned int)jarg3;
76449   {
76450     try {
76451       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76452     } catch (std::out_of_range& e) {
76453       {
76454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76455       };
76456     } catch (std::exception& e) {
76457       {
76458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76459       };
76460     } catch (...) {
76461       {
76462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76463       };
76464     }
76465   }
76466   jresult = (void *)result;
76467   return jresult;
76468 }
76469
76470
76471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76472   void * jresult ;
76473   unsigned int arg1 ;
76474   unsigned int arg2 ;
76475   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76476
76477   arg1 = (unsigned int)jarg1;
76478   arg2 = (unsigned int)jarg2;
76479   {
76480     try {
76481       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76482     } catch (std::out_of_range& e) {
76483       {
76484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76485       };
76486     } catch (std::exception& e) {
76487       {
76488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76489       };
76490     } catch (...) {
76491       {
76492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76493       };
76494     }
76495   }
76496   jresult = (void *)result;
76497   return jresult;
76498 }
76499
76500
76501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76502   void * jresult ;
76503   unsigned int arg1 ;
76504   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76505
76506   arg1 = (unsigned int)jarg1;
76507   {
76508     try {
76509       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76510     } catch (std::out_of_range& e) {
76511       {
76512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76513       };
76514     } catch (std::exception& e) {
76515       {
76516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76517       };
76518     } catch (...) {
76519       {
76520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76521       };
76522     }
76523   }
76524   jresult = (void *)result;
76525   return jresult;
76526 }
76527
76528
76529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76530   void * jresult ;
76531   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76532
76533   {
76534     try {
76535       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76536     } catch (std::out_of_range& e) {
76537       {
76538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76539       };
76540     } catch (std::exception& e) {
76541       {
76542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76543       };
76544     } catch (...) {
76545       {
76546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76547       };
76548     }
76549   }
76550   jresult = (void *)result;
76551   return jresult;
76552 }
76553
76554
76555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex = arg2;
76562 }
76563
76564
76565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_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)->rowIndex);
76572   jresult = result;
76573   return jresult;
76574 }
76575
76576
76577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex = arg2;
76584 }
76585
76586
76587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_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)->columnIndex);
76594   jresult = result;
76595   return jresult;
76596 }
76597
76598
76599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan = arg2;
76606 }
76607
76608
76609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_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)->rowSpan);
76616   jresult = result;
76617   return jresult;
76618 }
76619
76620
76621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76622   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76623   unsigned int arg2 ;
76624
76625   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76626   arg2 = (unsigned int)jarg2;
76627   if (arg1) (arg1)->columnSpan = arg2;
76628 }
76629
76630
76631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76632   unsigned int jresult ;
76633   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76634   unsigned int result;
76635
76636   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76637   result = (unsigned int) ((arg1)->columnSpan);
76638   jresult = result;
76639   return jresult;
76640 }
76641
76642
76643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76644   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76645
76646   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76647   {
76648     try {
76649       delete arg1;
76650     } catch (std::out_of_range& e) {
76651       {
76652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76653       };
76654     } catch (std::exception& e) {
76655       {
76656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76657       };
76658     } catch (...) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76661       };
76662     }
76663   }
76664 }
76665
76666
76667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76668   void * jresult ;
76669   Dali::Toolkit::TableView *result = 0 ;
76670
76671   {
76672     try {
76673       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76674     } catch (std::out_of_range& e) {
76675       {
76676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76677       };
76678     } catch (std::exception& e) {
76679       {
76680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (...) {
76683       {
76684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76685       };
76686     }
76687   }
76688   jresult = (void *)result;
76689   return jresult;
76690 }
76691
76692
76693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76694   void * jresult ;
76695   Dali::Toolkit::TableView *arg1 = 0 ;
76696   Dali::Toolkit::TableView *result = 0 ;
76697
76698   arg1 = (Dali::Toolkit::TableView *)jarg1;
76699   if (!arg1) {
76700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76701     return 0;
76702   }
76703   {
76704     try {
76705       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76706     } catch (std::out_of_range& e) {
76707       {
76708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76709       };
76710     } catch (std::exception& e) {
76711       {
76712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76713       };
76714     } catch (...) {
76715       {
76716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76717       };
76718     }
76719   }
76720   jresult = (void *)result;
76721   return jresult;
76722 }
76723
76724
76725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76726   void * jresult ;
76727   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76728   Dali::Toolkit::TableView *arg2 = 0 ;
76729   Dali::Toolkit::TableView *result = 0 ;
76730
76731   arg1 = (Dali::Toolkit::TableView *)jarg1;
76732   arg2 = (Dali::Toolkit::TableView *)jarg2;
76733   if (!arg2) {
76734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76735     return 0;
76736   }
76737   {
76738     try {
76739       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76740     } catch (std::out_of_range& e) {
76741       {
76742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76743       };
76744     } catch (std::exception& e) {
76745       {
76746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76747       };
76748     } catch (...) {
76749       {
76750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76751       };
76752     }
76753   }
76754   jresult = (void *)result;
76755   return jresult;
76756 }
76757
76758
76759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76760   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76761
76762   arg1 = (Dali::Toolkit::TableView *)jarg1;
76763   {
76764     try {
76765       delete arg1;
76766     } catch (std::out_of_range& e) {
76767       {
76768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76769       };
76770     } catch (std::exception& e) {
76771       {
76772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76773       };
76774     } catch (...) {
76775       {
76776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76777       };
76778     }
76779   }
76780 }
76781
76782
76783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76784   void * jresult ;
76785   unsigned int arg1 ;
76786   unsigned int arg2 ;
76787   Dali::Toolkit::TableView result;
76788
76789   arg1 = (unsigned int)jarg1;
76790   arg2 = (unsigned int)jarg2;
76791   {
76792     try {
76793       result = Dali::Toolkit::TableView::New(arg1,arg2);
76794     } catch (std::out_of_range& e) {
76795       {
76796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76797       };
76798     } catch (std::exception& e) {
76799       {
76800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76801       };
76802     } catch (...) {
76803       {
76804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76805       };
76806     }
76807   }
76808   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76809   return jresult;
76810 }
76811
76812
76813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76814   void * jresult ;
76815   Dali::BaseHandle arg1 ;
76816   Dali::BaseHandle *argp1 ;
76817   Dali::Toolkit::TableView result;
76818
76819   argp1 = (Dali::BaseHandle *)jarg1;
76820   if (!argp1) {
76821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76822     return 0;
76823   }
76824   arg1 = *argp1;
76825   {
76826     try {
76827       result = Dali::Toolkit::TableView::DownCast(arg1);
76828     } catch (std::out_of_range& e) {
76829       {
76830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76831       };
76832     } catch (std::exception& e) {
76833       {
76834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76835       };
76836     } catch (...) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76839       };
76840     }
76841   }
76842   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76843   return jresult;
76844 }
76845
76846
76847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76848   unsigned int jresult ;
76849   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76850   Dali::Actor arg2 ;
76851   Dali::Toolkit::TableView::CellPosition arg3 ;
76852   Dali::Actor *argp2 ;
76853   Dali::Toolkit::TableView::CellPosition *argp3 ;
76854   bool result;
76855
76856   arg1 = (Dali::Toolkit::TableView *)jarg1;
76857   argp2 = (Dali::Actor *)jarg2;
76858   if (!argp2) {
76859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76860     return 0;
76861   }
76862   arg2 = *argp2;
76863   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76864   if (!argp3) {
76865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76866     return 0;
76867   }
76868   arg3 = *argp3;
76869   {
76870     try {
76871       result = (bool)(arg1)->AddChild(arg2,arg3);
76872     } catch (std::out_of_range& e) {
76873       {
76874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76875       };
76876     } catch (std::exception& e) {
76877       {
76878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76879       };
76880     } catch (...) {
76881       {
76882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76883       };
76884     }
76885   }
76886   jresult = result;
76887   return jresult;
76888 }
76889
76890
76891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76892   void * jresult ;
76893   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76894   Dali::Toolkit::TableView::CellPosition arg2 ;
76895   Dali::Toolkit::TableView::CellPosition *argp2 ;
76896   Dali::Actor result;
76897
76898   arg1 = (Dali::Toolkit::TableView *)jarg1;
76899   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76900   if (!argp2) {
76901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76902     return 0;
76903   }
76904   arg2 = *argp2;
76905   {
76906     try {
76907       result = (arg1)->GetChildAt(arg2);
76908     } catch (std::out_of_range& e) {
76909       {
76910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76911       };
76912     } catch (std::exception& e) {
76913       {
76914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76915       };
76916     } catch (...) {
76917       {
76918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76919       };
76920     }
76921   }
76922   jresult = new Dali::Actor((const Dali::Actor &)result);
76923   return jresult;
76924 }
76925
76926
76927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76928   void * jresult ;
76929   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76930   Dali::Toolkit::TableView::CellPosition arg2 ;
76931   Dali::Toolkit::TableView::CellPosition *argp2 ;
76932   Dali::Actor result;
76933
76934   arg1 = (Dali::Toolkit::TableView *)jarg1;
76935   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76936   if (!argp2) {
76937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76938     return 0;
76939   }
76940   arg2 = *argp2;
76941   {
76942     try {
76943       result = (arg1)->RemoveChildAt(arg2);
76944     } catch (std::out_of_range& e) {
76945       {
76946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76947       };
76948     } catch (std::exception& e) {
76949       {
76950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76951       };
76952     } catch (...) {
76953       {
76954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76955       };
76956     }
76957   }
76958   jresult = new Dali::Actor((const Dali::Actor &)result);
76959   return jresult;
76960 }
76961
76962
76963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76964   unsigned int jresult ;
76965   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76966   Dali::Actor arg2 ;
76967   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76968   Dali::Actor *argp2 ;
76969   bool result;
76970
76971   arg1 = (Dali::Toolkit::TableView *)jarg1;
76972   argp2 = (Dali::Actor *)jarg2;
76973   if (!argp2) {
76974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76975     return 0;
76976   }
76977   arg2 = *argp2;
76978   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76979   if (!arg3) {
76980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76981     return 0;
76982   }
76983   {
76984     try {
76985       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76986     } catch (std::out_of_range& e) {
76987       {
76988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76989       };
76990     } catch (std::exception& e) {
76991       {
76992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76993       };
76994     } catch (...) {
76995       {
76996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76997       };
76998     }
76999   }
77000   jresult = result;
77001   return jresult;
77002 }
77003
77004
77005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77006   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77007   unsigned int arg2 ;
77008
77009   arg1 = (Dali::Toolkit::TableView *)jarg1;
77010   arg2 = (unsigned int)jarg2;
77011   {
77012     try {
77013       (arg1)->InsertRow(arg2);
77014     } catch (std::out_of_range& e) {
77015       {
77016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77017       };
77018     } catch (std::exception& e) {
77019       {
77020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77021       };
77022     } catch (...) {
77023       {
77024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77025       };
77026     }
77027   }
77028 }
77029
77030
77031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77032   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77033   unsigned int arg2 ;
77034
77035   arg1 = (Dali::Toolkit::TableView *)jarg1;
77036   arg2 = (unsigned int)jarg2;
77037   {
77038     try {
77039       (arg1)->DeleteRow(arg2);
77040     } catch (std::out_of_range& e) {
77041       {
77042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77043       };
77044     } catch (std::exception& e) {
77045       {
77046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77047       };
77048     } catch (...) {
77049       {
77050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77051       };
77052     }
77053   }
77054 }
77055
77056
77057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77058   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77059   unsigned int arg2 ;
77060   std::vector< Dali::Actor > *arg3 = 0 ;
77061
77062   arg1 = (Dali::Toolkit::TableView *)jarg1;
77063   arg2 = (unsigned int)jarg2;
77064   arg3 = (std::vector< Dali::Actor > *)jarg3;
77065   if (!arg3) {
77066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77067     return ;
77068   }
77069   {
77070     try {
77071       (arg1)->DeleteRow(arg2,*arg3);
77072     } catch (std::out_of_range& e) {
77073       {
77074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77075       };
77076     } catch (std::exception& e) {
77077       {
77078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77079       };
77080     } catch (...) {
77081       {
77082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77083       };
77084     }
77085   }
77086 }
77087
77088
77089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77090   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77091   unsigned int arg2 ;
77092
77093   arg1 = (Dali::Toolkit::TableView *)jarg1;
77094   arg2 = (unsigned int)jarg2;
77095   {
77096     try {
77097       (arg1)->InsertColumn(arg2);
77098     } catch (std::out_of_range& e) {
77099       {
77100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77101       };
77102     } catch (std::exception& e) {
77103       {
77104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77105       };
77106     } catch (...) {
77107       {
77108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77109       };
77110     }
77111   }
77112 }
77113
77114
77115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77116   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77117   unsigned int arg2 ;
77118
77119   arg1 = (Dali::Toolkit::TableView *)jarg1;
77120   arg2 = (unsigned int)jarg2;
77121   {
77122     try {
77123       (arg1)->DeleteColumn(arg2);
77124     } catch (std::out_of_range& e) {
77125       {
77126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77127       };
77128     } catch (std::exception& e) {
77129       {
77130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77131       };
77132     } catch (...) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77135       };
77136     }
77137   }
77138 }
77139
77140
77141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77142   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77143   unsigned int arg2 ;
77144   std::vector< Dali::Actor > *arg3 = 0 ;
77145
77146   arg1 = (Dali::Toolkit::TableView *)jarg1;
77147   arg2 = (unsigned int)jarg2;
77148   arg3 = (std::vector< Dali::Actor > *)jarg3;
77149   if (!arg3) {
77150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77151     return ;
77152   }
77153   {
77154     try {
77155       (arg1)->DeleteColumn(arg2,*arg3);
77156     } catch (std::out_of_range& e) {
77157       {
77158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77159       };
77160     } catch (std::exception& e) {
77161       {
77162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77163       };
77164     } catch (...) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77167       };
77168     }
77169   }
77170 }
77171
77172
77173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77175   unsigned int arg2 ;
77176   unsigned int arg3 ;
77177
77178   arg1 = (Dali::Toolkit::TableView *)jarg1;
77179   arg2 = (unsigned int)jarg2;
77180   arg3 = (unsigned int)jarg3;
77181   {
77182     try {
77183       (arg1)->Resize(arg2,arg3);
77184     } catch (std::out_of_range& e) {
77185       {
77186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77187       };
77188     } catch (std::exception& e) {
77189       {
77190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77191       };
77192     } catch (...) {
77193       {
77194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77195       };
77196     }
77197   }
77198 }
77199
77200
77201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77202   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77203   unsigned int arg2 ;
77204   unsigned int arg3 ;
77205   std::vector< Dali::Actor > *arg4 = 0 ;
77206
77207   arg1 = (Dali::Toolkit::TableView *)jarg1;
77208   arg2 = (unsigned int)jarg2;
77209   arg3 = (unsigned int)jarg3;
77210   arg4 = (std::vector< Dali::Actor > *)jarg4;
77211   if (!arg4) {
77212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77213     return ;
77214   }
77215   {
77216     try {
77217       (arg1)->Resize(arg2,arg3,*arg4);
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77225       };
77226     } catch (...) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77229       };
77230     }
77231   }
77232 }
77233
77234
77235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77237   Dali::Size arg2 ;
77238   Dali::Size *argp2 ;
77239
77240   arg1 = (Dali::Toolkit::TableView *)jarg1;
77241   argp2 = (Dali::Size *)jarg2;
77242   if (!argp2) {
77243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77244     return ;
77245   }
77246   arg2 = *argp2;
77247   {
77248     try {
77249       (arg1)->SetCellPadding(arg2);
77250     } catch (std::out_of_range& e) {
77251       {
77252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77253       };
77254     } catch (std::exception& e) {
77255       {
77256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77257       };
77258     } catch (...) {
77259       {
77260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77261       };
77262     }
77263   }
77264 }
77265
77266
77267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77268   void * jresult ;
77269   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77270   Dali::Size result;
77271
77272   arg1 = (Dali::Toolkit::TableView *)jarg1;
77273   {
77274     try {
77275       result = (arg1)->GetCellPadding();
77276     } catch (std::out_of_range& e) {
77277       {
77278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77279       };
77280     } catch (std::exception& e) {
77281       {
77282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77287       };
77288     }
77289   }
77290   jresult = new Dali::Size((const Dali::Size &)result);
77291   return jresult;
77292 }
77293
77294
77295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77297   unsigned int arg2 ;
77298
77299   arg1 = (Dali::Toolkit::TableView *)jarg1;
77300   arg2 = (unsigned int)jarg2;
77301   {
77302     try {
77303       (arg1)->SetFitHeight(arg2);
77304     } catch (std::out_of_range& e) {
77305       {
77306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77307       };
77308     } catch (std::exception& e) {
77309       {
77310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77311       };
77312     } catch (...) {
77313       {
77314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77315       };
77316     }
77317   }
77318 }
77319
77320
77321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77322   unsigned int jresult ;
77323   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77324   unsigned int arg2 ;
77325   bool result;
77326
77327   arg1 = (Dali::Toolkit::TableView *)jarg1;
77328   arg2 = (unsigned int)jarg2;
77329   {
77330     try {
77331       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77332     } catch (std::out_of_range& e) {
77333       {
77334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77335       };
77336     } catch (std::exception& e) {
77337       {
77338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77339       };
77340     } catch (...) {
77341       {
77342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77343       };
77344     }
77345   }
77346   jresult = result;
77347   return jresult;
77348 }
77349
77350
77351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77353   unsigned int arg2 ;
77354
77355   arg1 = (Dali::Toolkit::TableView *)jarg1;
77356   arg2 = (unsigned int)jarg2;
77357   {
77358     try {
77359       (arg1)->SetFitWidth(arg2);
77360     } catch (std::out_of_range& e) {
77361       {
77362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77363       };
77364     } catch (std::exception& e) {
77365       {
77366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77367       };
77368     } catch (...) {
77369       {
77370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77371       };
77372     }
77373   }
77374 }
77375
77376
77377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77378   unsigned int jresult ;
77379   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77380   unsigned int arg2 ;
77381   bool result;
77382
77383   arg1 = (Dali::Toolkit::TableView *)jarg1;
77384   arg2 = (unsigned int)jarg2;
77385   {
77386     try {
77387       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77388     } catch (std::out_of_range& e) {
77389       {
77390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77391       };
77392     } catch (std::exception& e) {
77393       {
77394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77395       };
77396     } catch (...) {
77397       {
77398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77399       };
77400     }
77401   }
77402   jresult = result;
77403   return jresult;
77404 }
77405
77406
77407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77409   unsigned int arg2 ;
77410   float arg3 ;
77411
77412   arg1 = (Dali::Toolkit::TableView *)jarg1;
77413   arg2 = (unsigned int)jarg2;
77414   arg3 = (float)jarg3;
77415   {
77416     try {
77417       (arg1)->SetFixedHeight(arg2,arg3);
77418     } catch (std::out_of_range& e) {
77419       {
77420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77421       };
77422     } catch (std::exception& e) {
77423       {
77424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77425       };
77426     } catch (...) {
77427       {
77428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77429       };
77430     }
77431   }
77432 }
77433
77434
77435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77436   float jresult ;
77437   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77438   unsigned int arg2 ;
77439   float result;
77440
77441   arg1 = (Dali::Toolkit::TableView *)jarg1;
77442   arg2 = (unsigned int)jarg2;
77443   {
77444     try {
77445       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77446     } catch (std::out_of_range& e) {
77447       {
77448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77449       };
77450     } catch (std::exception& e) {
77451       {
77452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77453       };
77454     } catch (...) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77457       };
77458     }
77459   }
77460   jresult = result;
77461   return jresult;
77462 }
77463
77464
77465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77466   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77467   unsigned int arg2 ;
77468   float arg3 ;
77469
77470   arg1 = (Dali::Toolkit::TableView *)jarg1;
77471   arg2 = (unsigned int)jarg2;
77472   arg3 = (float)jarg3;
77473   {
77474     try {
77475       (arg1)->SetRelativeHeight(arg2,arg3);
77476     } catch (std::out_of_range& e) {
77477       {
77478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77479       };
77480     } catch (std::exception& e) {
77481       {
77482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77483       };
77484     } catch (...) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77487       };
77488     }
77489   }
77490 }
77491
77492
77493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77494   float jresult ;
77495   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77496   unsigned int arg2 ;
77497   float result;
77498
77499   arg1 = (Dali::Toolkit::TableView *)jarg1;
77500   arg2 = (unsigned int)jarg2;
77501   {
77502     try {
77503       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77504     } catch (std::out_of_range& e) {
77505       {
77506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77507       };
77508     } catch (std::exception& e) {
77509       {
77510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77511       };
77512     } catch (...) {
77513       {
77514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77515       };
77516     }
77517   }
77518   jresult = result;
77519   return jresult;
77520 }
77521
77522
77523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77524   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77525   unsigned int arg2 ;
77526   float arg3 ;
77527
77528   arg1 = (Dali::Toolkit::TableView *)jarg1;
77529   arg2 = (unsigned int)jarg2;
77530   arg3 = (float)jarg3;
77531   {
77532     try {
77533       (arg1)->SetFixedWidth(arg2,arg3);
77534     } catch (std::out_of_range& e) {
77535       {
77536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77537       };
77538     } catch (std::exception& e) {
77539       {
77540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77541       };
77542     } catch (...) {
77543       {
77544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77545       };
77546     }
77547   }
77548 }
77549
77550
77551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77552   float jresult ;
77553   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77554   unsigned int arg2 ;
77555   float result;
77556
77557   arg1 = (Dali::Toolkit::TableView *)jarg1;
77558   arg2 = (unsigned int)jarg2;
77559   {
77560     try {
77561       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77562     } catch (std::out_of_range& e) {
77563       {
77564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77565       };
77566     } catch (std::exception& e) {
77567       {
77568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77569       };
77570     } catch (...) {
77571       {
77572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77573       };
77574     }
77575   }
77576   jresult = result;
77577   return jresult;
77578 }
77579
77580
77581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77582   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77583   unsigned int arg2 ;
77584   float arg3 ;
77585
77586   arg1 = (Dali::Toolkit::TableView *)jarg1;
77587   arg2 = (unsigned int)jarg2;
77588   arg3 = (float)jarg3;
77589   {
77590     try {
77591       (arg1)->SetRelativeWidth(arg2,arg3);
77592     } catch (std::out_of_range& e) {
77593       {
77594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77595       };
77596     } catch (std::exception& e) {
77597       {
77598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77599       };
77600     } catch (...) {
77601       {
77602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77603       };
77604     }
77605   }
77606 }
77607
77608
77609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77610   float jresult ;
77611   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77612   unsigned int arg2 ;
77613   float result;
77614
77615   arg1 = (Dali::Toolkit::TableView *)jarg1;
77616   arg2 = (unsigned int)jarg2;
77617   {
77618     try {
77619       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77620     } catch (std::out_of_range& e) {
77621       {
77622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77623       };
77624     } catch (std::exception& e) {
77625       {
77626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77627       };
77628     } catch (...) {
77629       {
77630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77631       };
77632     }
77633   }
77634   jresult = result;
77635   return jresult;
77636 }
77637
77638
77639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77640   unsigned int jresult ;
77641   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77642   unsigned int result;
77643
77644   arg1 = (Dali::Toolkit::TableView *)jarg1;
77645   {
77646     try {
77647       result = (unsigned int)(arg1)->GetRows();
77648     } catch (std::out_of_range& e) {
77649       {
77650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77651       };
77652     } catch (std::exception& e) {
77653       {
77654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77655       };
77656     } catch (...) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77659       };
77660     }
77661   }
77662   jresult = result;
77663   return jresult;
77664 }
77665
77666
77667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77668   unsigned int jresult ;
77669   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77670   unsigned int result;
77671
77672   arg1 = (Dali::Toolkit::TableView *)jarg1;
77673   {
77674     try {
77675       result = (unsigned int)(arg1)->GetColumns();
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77687       };
77688     }
77689   }
77690   jresult = result;
77691   return jresult;
77692 }
77693
77694
77695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77696   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77697   Dali::Toolkit::TableView::CellPosition arg2 ;
77698   Dali::HorizontalAlignment::Type arg3 ;
77699   Dali::VerticalAlignment::Type arg4 ;
77700   Dali::Toolkit::TableView::CellPosition *argp2 ;
77701
77702   arg1 = (Dali::Toolkit::TableView *)jarg1;
77703   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77704   if (!argp2) {
77705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77706     return ;
77707   }
77708   arg2 = *argp2;
77709   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77710   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77711   {
77712     try {
77713       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77714     } catch (std::out_of_range& e) {
77715       {
77716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77717       };
77718     } catch (std::exception& e) {
77719       {
77720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77721       };
77722     } catch (...) {
77723       {
77724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77725       };
77726     }
77727   }
77728 }
77729
77730
77731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77732   unsigned int jresult ;
77733   unsigned int result;
77734
77735   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77736   jresult = result;
77737   return jresult;
77738 }
77739
77740
77741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77742   int jresult ;
77743   int result;
77744
77745   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77746   jresult = (int)result;
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77752   int jresult ;
77753   int result;
77754
77755   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77756   jresult = (int)result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77762   int jresult ;
77763   int result;
77764
77765   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77766   jresult = (int)result;
77767   return jresult;
77768 }
77769
77770
77771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77772   int jresult ;
77773   int result;
77774
77775   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77776   jresult = (int)result;
77777   return jresult;
77778 }
77779
77780
77781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77782   int jresult ;
77783   int result;
77784
77785   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77786   jresult = (int)result;
77787   return jresult;
77788 }
77789
77790
77791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77792   int jresult ;
77793   int result;
77794
77795   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77796   jresult = (int)result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77802   int jresult ;
77803   int result;
77804
77805   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77806   jresult = (int)result;
77807   return jresult;
77808 }
77809
77810
77811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77812   int jresult ;
77813   int result;
77814
77815   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77816   jresult = (int)result;
77817   return jresult;
77818 }
77819
77820
77821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77822   int jresult ;
77823   int result;
77824
77825   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77826   jresult = (int)result;
77827   return jresult;
77828 }
77829
77830
77831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77832   int jresult ;
77833   int result;
77834
77835   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77836   jresult = (int)result;
77837   return jresult;
77838 }
77839
77840
77841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77842   int jresult ;
77843   int result;
77844
77845   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77846   jresult = (int)result;
77847   return jresult;
77848 }
77849
77850
77851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77852   int jresult ;
77853   int result;
77854
77855   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77856   jresult = (int)result;
77857   return jresult;
77858 }
77859
77860
77861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77862   int jresult ;
77863   int result;
77864
77865   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77866   jresult = (int)result;
77867   return jresult;
77868 }
77869
77870
77871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77872   int jresult ;
77873   int result;
77874
77875   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77876   jresult = (int)result;
77877   return jresult;
77878 }
77879
77880
77881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77882   int jresult ;
77883   int result;
77884
77885   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77886   jresult = (int)result;
77887   return jresult;
77888 }
77889
77890
77891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77892   int jresult ;
77893   int result;
77894
77895   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77896   jresult = (int)result;
77897   return jresult;
77898 }
77899
77900
77901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77902   int jresult ;
77903   int result;
77904
77905   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77906   jresult = (int)result;
77907   return jresult;
77908 }
77909
77910
77911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77912   int jresult ;
77913   int result;
77914
77915   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77916   jresult = (int)result;
77917   return jresult;
77918 }
77919
77920
77921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77922   int jresult ;
77923   int result;
77924
77925   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77926   jresult = (int)result;
77927   return jresult;
77928 }
77929
77930
77931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77932   int jresult ;
77933   int result;
77934
77935   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77936   jresult = (int)result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77942   int jresult ;
77943   int result;
77944
77945   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77946   jresult = (int)result;
77947   return jresult;
77948 }
77949
77950
77951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77952   int jresult ;
77953   int result;
77954
77955   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77956   jresult = (int)result;
77957   return jresult;
77958 }
77959
77960
77961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77962   int jresult ;
77963   int result;
77964
77965   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77966   jresult = (int)result;
77967   return jresult;
77968 }
77969
77970
77971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77972   int jresult ;
77973   int result;
77974
77975   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77976   jresult = (int)result;
77977   return jresult;
77978 }
77979
77980
77981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77982   int jresult ;
77983   int result;
77984
77985   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77986   jresult = (int)result;
77987   return jresult;
77988 }
77989
77990
77991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77992   int jresult ;
77993   int result;
77994
77995   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77996   jresult = (int)result;
77997   return jresult;
77998 }
77999
78000
78001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
78002   int jresult ;
78003   int result;
78004
78005   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
78006   jresult = (int)result;
78007   return jresult;
78008 }
78009
78010
78011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
78012   int jresult ;
78013   int result;
78014
78015   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
78016   jresult = (int)result;
78017   return jresult;
78018 }
78019
78020
78021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
78022   int jresult ;
78023   int result;
78024
78025   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
78026   jresult = (int)result;
78027   return jresult;
78028 }
78029
78030
78031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
78032   int jresult ;
78033   int result;
78034
78035   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
78036   jresult = (int)result;
78037   return jresult;
78038 }
78039
78040
78041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
78042   int jresult ;
78043   int result;
78044
78045   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
78046   jresult = (int)result;
78047   return jresult;
78048 }
78049
78050
78051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
78052   int jresult ;
78053   int result;
78054
78055   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
78056   jresult = (int)result;
78057   return jresult;
78058 }
78059
78060
78061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
78062   int jresult ;
78063   int result;
78064
78065   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
78066   jresult = (int)result;
78067   return jresult;
78068 }
78069
78070
78071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
78072   int jresult ;
78073   int result;
78074
78075   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
78076   jresult = (int)result;
78077   return jresult;
78078 }
78079
78080
78081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
78082   int jresult ;
78083   int result;
78084
78085   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
78086   jresult = (int)result;
78087   return jresult;
78088 }
78089
78090
78091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
78092   int jresult ;
78093   int result;
78094
78095   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
78096   jresult = (int)result;
78097   return jresult;
78098 }
78099
78100
78101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78102   int jresult ;
78103   int result;
78104
78105   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78106   jresult = (int)result;
78107   return jresult;
78108 }
78109
78110
78111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78112   int jresult ;
78113   int result;
78114
78115   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78116   jresult = (int)result;
78117   return jresult;
78118 }
78119
78120
78121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78122   int jresult ;
78123   int result;
78124
78125   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78126   jresult = (int)result;
78127   return jresult;
78128 }
78129
78130
78131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78132   int jresult ;
78133   int result;
78134
78135   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78136   jresult = (int)result;
78137   return jresult;
78138 }
78139
78140
78141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78142   void * jresult ;
78143   Dali::Toolkit::TextEditor::Property *result = 0 ;
78144
78145   {
78146     try {
78147       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78148     } catch (std::out_of_range& e) {
78149       {
78150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78151       };
78152     } catch (std::exception& e) {
78153       {
78154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78155       };
78156     } catch (...) {
78157       {
78158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78159       };
78160     }
78161   }
78162   jresult = (void *)result;
78163   return jresult;
78164 }
78165
78166
78167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78168   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78169
78170   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78171   {
78172     try {
78173       delete arg1;
78174     } catch (std::out_of_range& e) {
78175       {
78176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78177       };
78178     } catch (std::exception& e) {
78179       {
78180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78181       };
78182     } catch (...) {
78183       {
78184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78185       };
78186     }
78187   }
78188 }
78189
78190
78191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78192   void * jresult ;
78193   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78194
78195   {
78196     try {
78197       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78198     } catch (std::out_of_range& e) {
78199       {
78200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78201       };
78202     } catch (std::exception& e) {
78203       {
78204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78205       };
78206     } catch (...) {
78207       {
78208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78209       };
78210     }
78211   }
78212   jresult = (void *)result;
78213   return jresult;
78214 }
78215
78216
78217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78218   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78219
78220   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78221   {
78222     try {
78223       delete arg1;
78224     } catch (std::out_of_range& e) {
78225       {
78226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78227       };
78228     } catch (std::exception& e) {
78229       {
78230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78231       };
78232     } catch (...) {
78233       {
78234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78235       };
78236     }
78237   }
78238 }
78239
78240
78241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78242   void * jresult ;
78243   Dali::Toolkit::TextEditor result;
78244
78245   {
78246     try {
78247       result = Dali::Toolkit::TextEditor::New();
78248     } catch (std::out_of_range& e) {
78249       {
78250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78251       };
78252     } catch (std::exception& e) {
78253       {
78254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78255       };
78256     } catch (...) {
78257       {
78258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78259       };
78260     }
78261   }
78262   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78263   return jresult;
78264 }
78265
78266
78267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78268   void * jresult ;
78269   Dali::Toolkit::TextEditor *result = 0 ;
78270
78271   {
78272     try {
78273       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78274     } catch (std::out_of_range& e) {
78275       {
78276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78277       };
78278     } catch (std::exception& e) {
78279       {
78280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78281       };
78282     } catch (...) {
78283       {
78284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78285       };
78286     }
78287   }
78288   jresult = (void *)result;
78289   return jresult;
78290 }
78291
78292
78293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78294   void * jresult ;
78295   Dali::Toolkit::TextEditor *arg1 = 0 ;
78296   Dali::Toolkit::TextEditor *result = 0 ;
78297
78298   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78299   if (!arg1) {
78300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78301     return 0;
78302   }
78303   {
78304     try {
78305       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78306     } catch (std::out_of_range& e) {
78307       {
78308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78309       };
78310     } catch (std::exception& e) {
78311       {
78312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78313       };
78314     } catch (...) {
78315       {
78316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78317       };
78318     }
78319   }
78320   jresult = (void *)result;
78321   return jresult;
78322 }
78323
78324
78325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78326   void * jresult ;
78327   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78328   Dali::Toolkit::TextEditor *arg2 = 0 ;
78329   Dali::Toolkit::TextEditor *result = 0 ;
78330
78331   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78332   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78333   if (!arg2) {
78334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78335     return 0;
78336   }
78337   {
78338     try {
78339       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78340     } catch (std::out_of_range& e) {
78341       {
78342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78343       };
78344     } catch (std::exception& e) {
78345       {
78346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (...) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78351       };
78352     }
78353   }
78354   jresult = (void *)result;
78355   return jresult;
78356 }
78357
78358
78359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78360   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78361
78362   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78363   {
78364     try {
78365       delete arg1;
78366     } catch (std::out_of_range& e) {
78367       {
78368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78369       };
78370     } catch (std::exception& e) {
78371       {
78372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78373       };
78374     } catch (...) {
78375       {
78376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78377       };
78378     }
78379   }
78380 }
78381
78382
78383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78384   void * jresult ;
78385   Dali::BaseHandle arg1 ;
78386   Dali::BaseHandle *argp1 ;
78387   Dali::Toolkit::TextEditor result;
78388
78389   argp1 = (Dali::BaseHandle *)jarg1;
78390   if (!argp1) {
78391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78392     return 0;
78393   }
78394   arg1 = *argp1;
78395   {
78396     try {
78397       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78398     } catch (std::out_of_range& e) {
78399       {
78400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78401       };
78402     } catch (std::exception& e) {
78403       {
78404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78405       };
78406     } catch (...) {
78407       {
78408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78409       };
78410     }
78411   }
78412   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78413   return jresult;
78414 }
78415
78416
78417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78418   void * jresult ;
78419   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78420   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78421
78422   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78423   {
78424     try {
78425       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78426     } catch (std::out_of_range& e) {
78427       {
78428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78429       };
78430     } catch (std::exception& e) {
78431       {
78432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78433       };
78434     } catch (...) {
78435       {
78436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78437       };
78438     }
78439   }
78440   jresult = (void *)result;
78441   return jresult;
78442 }
78443
78444
78445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78446   void * jresult ;
78447   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78448   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78449
78450   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78451   {
78452     try {
78453       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78454     } catch (std::out_of_range& e) {
78455       {
78456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78457       };
78458     } catch (std::exception& e) {
78459       {
78460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78461       };
78462     } catch (...) {
78463       {
78464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78465       };
78466     }
78467   }
78468   jresult = (void *)result;
78469   return jresult;
78470 }
78471
78472
78473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78474   int jresult ;
78475   int result;
78476
78477   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78478   jresult = (int)result;
78479   return jresult;
78480 }
78481
78482
78483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78484   int jresult ;
78485   int result;
78486
78487   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78488   jresult = (int)result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78494   int jresult ;
78495   int result;
78496
78497   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78498   jresult = (int)result;
78499   return jresult;
78500 }
78501
78502
78503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78504   int jresult ;
78505   int result;
78506
78507   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78508   jresult = (int)result;
78509   return jresult;
78510 }
78511
78512
78513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78514   int jresult ;
78515   int result;
78516
78517   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78518   jresult = (int)result;
78519   return jresult;
78520 }
78521
78522
78523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78524   int jresult ;
78525   int result;
78526
78527   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78528   jresult = (int)result;
78529   return jresult;
78530 }
78531
78532
78533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78534   int jresult ;
78535   int result;
78536
78537   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78538   jresult = (int)result;
78539   return jresult;
78540 }
78541
78542
78543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78544   int jresult ;
78545   int result;
78546
78547   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78548   jresult = (int)result;
78549   return jresult;
78550 }
78551
78552
78553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78554   int jresult ;
78555   int result;
78556
78557   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78558   jresult = (int)result;
78559   return jresult;
78560 }
78561
78562
78563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78564   int jresult ;
78565   int result;
78566
78567   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78568   jresult = (int)result;
78569   return jresult;
78570 }
78571
78572
78573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78574   int jresult ;
78575   int result;
78576
78577   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78578   jresult = (int)result;
78579   return jresult;
78580 }
78581
78582
78583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78584   int jresult ;
78585   int result;
78586
78587   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78588   jresult = (int)result;
78589   return jresult;
78590 }
78591
78592
78593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78594   int jresult ;
78595   int result;
78596
78597   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78598   jresult = (int)result;
78599   return jresult;
78600 }
78601
78602
78603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78604   int jresult ;
78605   int result;
78606
78607   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78608   jresult = (int)result;
78609   return jresult;
78610 }
78611
78612
78613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78614   int jresult ;
78615   int result;
78616
78617   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78618   jresult = (int)result;
78619   return jresult;
78620 }
78621
78622
78623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78624   int jresult ;
78625   int result;
78626
78627   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78628   jresult = (int)result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78634   int jresult ;
78635   int result;
78636
78637   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78638   jresult = (int)result;
78639   return jresult;
78640 }
78641
78642
78643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78644   int jresult ;
78645   int result;
78646
78647   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78648   jresult = (int)result;
78649   return jresult;
78650 }
78651
78652
78653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78654   int jresult ;
78655   int result;
78656
78657   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78658   jresult = (int)result;
78659   return jresult;
78660 }
78661
78662
78663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78664   int jresult ;
78665   int result;
78666
78667   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78668   jresult = (int)result;
78669   return jresult;
78670 }
78671
78672
78673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78674   int jresult ;
78675   int result;
78676
78677   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78678   jresult = (int)result;
78679   return jresult;
78680 }
78681
78682
78683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78684   int jresult ;
78685   int result;
78686
78687   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78688   jresult = (int)result;
78689   return jresult;
78690 }
78691
78692
78693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78694   int jresult ;
78695   int result;
78696
78697   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78698   jresult = (int)result;
78699   return jresult;
78700 }
78701
78702
78703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78704   int jresult ;
78705   int result;
78706
78707   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78708   jresult = (int)result;
78709   return jresult;
78710 }
78711
78712
78713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78714   int jresult ;
78715   int result;
78716
78717   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78718   jresult = (int)result;
78719   return jresult;
78720 }
78721
78722
78723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78724   int jresult ;
78725   int result;
78726
78727   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78728   jresult = (int)result;
78729   return jresult;
78730 }
78731
78732
78733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78734   int jresult ;
78735   int result;
78736
78737   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78738   jresult = (int)result;
78739   return jresult;
78740 }
78741
78742
78743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78744   int jresult ;
78745   int result;
78746
78747   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78748   jresult = (int)result;
78749   return jresult;
78750 }
78751
78752
78753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78754   int jresult ;
78755   int result;
78756
78757   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78758   jresult = (int)result;
78759   return jresult;
78760 }
78761
78762
78763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78764   int jresult ;
78765   int result;
78766
78767   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78768   jresult = (int)result;
78769   return jresult;
78770 }
78771
78772
78773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78774   int jresult ;
78775   int result;
78776
78777   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78778   jresult = (int)result;
78779   return jresult;
78780 }
78781
78782
78783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78784   int jresult ;
78785   int result;
78786
78787   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78788   jresult = (int)result;
78789   return jresult;
78790 }
78791
78792
78793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78794   int jresult ;
78795   int result;
78796
78797   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78798   jresult = (int)result;
78799   return jresult;
78800 }
78801
78802
78803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78804   int jresult ;
78805   int result;
78806
78807   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78808   jresult = (int)result;
78809   return jresult;
78810 }
78811
78812
78813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78814   int jresult ;
78815   int result;
78816
78817   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78818   jresult = (int)result;
78819   return jresult;
78820 }
78821
78822
78823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78824   int jresult ;
78825   int result;
78826
78827   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78828   jresult = (int)result;
78829   return jresult;
78830 }
78831
78832
78833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78834   int jresult ;
78835   int result;
78836
78837   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78838   jresult = (int)result;
78839   return jresult;
78840 }
78841
78842
78843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78844   int jresult ;
78845   int result;
78846
78847   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78848   jresult = (int)result;
78849   return jresult;
78850 }
78851
78852
78853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78854   int jresult ;
78855   int result;
78856
78857   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78858   jresult = (int)result;
78859   return jresult;
78860 }
78861
78862
78863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78864   int jresult ;
78865   int result;
78866
78867   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78868   jresult = (int)result;
78869   return jresult;
78870 }
78871
78872
78873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78874   int jresult ;
78875   int result;
78876
78877   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78878   jresult = (int)result;
78879   return jresult;
78880 }
78881
78882
78883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78884   int jresult ;
78885   int result;
78886
78887   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78888   jresult = (int)result;
78889   return jresult;
78890 }
78891
78892
78893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78894   int jresult ;
78895   int result;
78896
78897   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78898   jresult = (int)result;
78899   return jresult;
78900 }
78901
78902
78903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78904   int jresult ;
78905   int result;
78906
78907   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78908   jresult = (int)result;
78909   return jresult;
78910 }
78911
78912
78913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78914   int jresult ;
78915   int result;
78916
78917   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78918   jresult = (int)result;
78919   return jresult;
78920 }
78921
78922
78923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78924   int jresult ;
78925   int result;
78926
78927   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78928   jresult = (int)result;
78929   return jresult;
78930 }
78931
78932
78933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78934   int jresult ;
78935   int result;
78936
78937   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78938   jresult = (int)result;
78939   return jresult;
78940 }
78941
78942
78943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78944   void * jresult ;
78945   Dali::Toolkit::TextField::Property *result = 0 ;
78946
78947   {
78948     try {
78949       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78950     } catch (std::out_of_range& e) {
78951       {
78952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (std::exception& e) {
78955       {
78956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78957       };
78958     } catch (...) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78961       };
78962     }
78963   }
78964   jresult = (void *)result;
78965   return jresult;
78966 }
78967
78968
78969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78970   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78971
78972   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78973   {
78974     try {
78975       delete arg1;
78976     } catch (std::out_of_range& e) {
78977       {
78978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78979       };
78980     } catch (std::exception& e) {
78981       {
78982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78983       };
78984     } catch (...) {
78985       {
78986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78987       };
78988     }
78989   }
78990 }
78991
78992
78993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78994   void * jresult ;
78995   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78996
78997   {
78998     try {
78999       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
79000     } catch (std::out_of_range& e) {
79001       {
79002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79003       };
79004     } catch (std::exception& e) {
79005       {
79006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79007       };
79008     } catch (...) {
79009       {
79010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79011       };
79012     }
79013   }
79014   jresult = (void *)result;
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
79020   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
79021
79022   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
79023   {
79024     try {
79025       delete arg1;
79026     } catch (std::out_of_range& e) {
79027       {
79028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79029       };
79030     } catch (std::exception& e) {
79031       {
79032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79033       };
79034     } catch (...) {
79035       {
79036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79037       };
79038     }
79039   }
79040 }
79041
79042
79043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
79044   void * jresult ;
79045   Dali::Toolkit::TextField result;
79046
79047   {
79048     try {
79049       result = Dali::Toolkit::TextField::New();
79050     } catch (std::out_of_range& e) {
79051       {
79052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79053       };
79054     } catch (std::exception& e) {
79055       {
79056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79057       };
79058     } catch (...) {
79059       {
79060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79061       };
79062     }
79063   }
79064   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79065   return jresult;
79066 }
79067
79068
79069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
79070   void * jresult ;
79071   Dali::Toolkit::TextField *result = 0 ;
79072
79073   {
79074     try {
79075       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
79076     } catch (std::out_of_range& e) {
79077       {
79078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79079       };
79080     } catch (std::exception& e) {
79081       {
79082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79083       };
79084     } catch (...) {
79085       {
79086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79087       };
79088     }
79089   }
79090   jresult = (void *)result;
79091   return jresult;
79092 }
79093
79094
79095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
79096   void * jresult ;
79097   Dali::Toolkit::TextField *arg1 = 0 ;
79098   Dali::Toolkit::TextField *result = 0 ;
79099
79100   arg1 = (Dali::Toolkit::TextField *)jarg1;
79101   if (!arg1) {
79102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79103     return 0;
79104   }
79105   {
79106     try {
79107       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79108     } catch (std::out_of_range& e) {
79109       {
79110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79111       };
79112     } catch (std::exception& e) {
79113       {
79114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79115       };
79116     } catch (...) {
79117       {
79118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79119       };
79120     }
79121   }
79122   jresult = (void *)result;
79123   return jresult;
79124 }
79125
79126
79127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79128   void * jresult ;
79129   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79130   Dali::Toolkit::TextField *arg2 = 0 ;
79131   Dali::Toolkit::TextField *result = 0 ;
79132
79133   arg1 = (Dali::Toolkit::TextField *)jarg1;
79134   arg2 = (Dali::Toolkit::TextField *)jarg2;
79135   if (!arg2) {
79136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79137     return 0;
79138   }
79139   {
79140     try {
79141       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79142     } catch (std::out_of_range& e) {
79143       {
79144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (std::exception& e) {
79147       {
79148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79153       };
79154     }
79155   }
79156   jresult = (void *)result;
79157   return jresult;
79158 }
79159
79160
79161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79162   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79163
79164   arg1 = (Dali::Toolkit::TextField *)jarg1;
79165   {
79166     try {
79167       delete arg1;
79168     } catch (std::out_of_range& e) {
79169       {
79170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79171       };
79172     } catch (std::exception& e) {
79173       {
79174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79175       };
79176     } catch (...) {
79177       {
79178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79179       };
79180     }
79181   }
79182 }
79183
79184
79185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79186   void * jresult ;
79187   Dali::BaseHandle arg1 ;
79188   Dali::BaseHandle *argp1 ;
79189   Dali::Toolkit::TextField result;
79190
79191   argp1 = (Dali::BaseHandle *)jarg1;
79192   if (!argp1) {
79193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79194     return 0;
79195   }
79196   arg1 = *argp1;
79197   {
79198     try {
79199       result = Dali::Toolkit::TextField::DownCast(arg1);
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (...) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79211       };
79212     }
79213   }
79214   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79215   return jresult;
79216 }
79217
79218
79219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79220   void * jresult ;
79221   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79222   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79223
79224   arg1 = (Dali::Toolkit::TextField *)jarg1;
79225   {
79226     try {
79227       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79228     } catch (std::out_of_range& e) {
79229       {
79230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79231       };
79232     } catch (std::exception& e) {
79233       {
79234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79235       };
79236     } catch (...) {
79237       {
79238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79239       };
79240     }
79241   }
79242   jresult = (void *)result;
79243   return jresult;
79244 }
79245
79246
79247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79248   void * jresult ;
79249   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79250   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79251
79252   arg1 = (Dali::Toolkit::TextField *)jarg1;
79253   {
79254     try {
79255       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79256     } catch (std::out_of_range& e) {
79257       {
79258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79259       };
79260     } catch (std::exception& e) {
79261       {
79262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79263       };
79264     } catch (...) {
79265       {
79266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79267       };
79268     }
79269   }
79270   jresult = (void *)result;
79271   return jresult;
79272 }
79273
79274
79275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79276   void * jresult ;
79277   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79278   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79279
79280   arg1 = (Dali::Toolkit::TextField *)jarg1;
79281   {
79282     try {
79283       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79284     } catch (std::out_of_range& e) {
79285       {
79286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79287       };
79288     } catch (std::exception& e) {
79289       {
79290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79291       };
79292     } catch (...) {
79293       {
79294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79295       };
79296     }
79297   }
79298   jresult = (void *)result;
79299   return jresult;
79300 }
79301
79302
79303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79304   int jresult ;
79305   int result;
79306
79307   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79308   jresult = (int)result;
79309   return jresult;
79310 }
79311
79312
79313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79314   int jresult ;
79315   int result;
79316
79317   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79318   jresult = (int)result;
79319   return jresult;
79320 }
79321
79322
79323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79324   int jresult ;
79325   int result;
79326
79327   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79328   jresult = (int)result;
79329   return jresult;
79330 }
79331
79332
79333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79334   int jresult ;
79335   int result;
79336
79337   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79338   jresult = (int)result;
79339   return jresult;
79340 }
79341
79342
79343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79344   int jresult ;
79345   int result;
79346
79347   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79348   jresult = (int)result;
79349   return jresult;
79350 }
79351
79352
79353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79354   int jresult ;
79355   int result;
79356
79357   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79358   jresult = (int)result;
79359   return jresult;
79360 }
79361
79362
79363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79364   int jresult ;
79365   int result;
79366
79367   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79368   jresult = (int)result;
79369   return jresult;
79370 }
79371
79372
79373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79374   int jresult ;
79375   int result;
79376
79377   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79378   jresult = (int)result;
79379   return jresult;
79380 }
79381
79382
79383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79384   int jresult ;
79385   int result;
79386
79387   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79388   jresult = (int)result;
79389   return jresult;
79390 }
79391
79392
79393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79394   int jresult ;
79395   int result;
79396
79397   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79398   jresult = (int)result;
79399   return jresult;
79400 }
79401
79402
79403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79404   int jresult ;
79405   int result;
79406
79407   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79408   jresult = (int)result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79414   int jresult ;
79415   int result;
79416
79417   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79418   jresult = (int)result;
79419   return jresult;
79420 }
79421
79422
79423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79424   int jresult ;
79425   int result;
79426
79427   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79428   jresult = (int)result;
79429   return jresult;
79430 }
79431
79432
79433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79434   int jresult ;
79435   int result;
79436
79437   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79438   jresult = (int)result;
79439   return jresult;
79440 }
79441
79442
79443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79444   int jresult ;
79445   int result;
79446
79447   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79448   jresult = (int)result;
79449   return jresult;
79450 }
79451
79452
79453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79454   int jresult ;
79455   int result;
79456
79457   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79458   jresult = (int)result;
79459   return jresult;
79460 }
79461
79462
79463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79464   int jresult ;
79465   int result;
79466
79467   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79468   jresult = (int)result;
79469   return jresult;
79470 }
79471
79472
79473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79474   int jresult ;
79475   int result;
79476
79477   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79478   jresult = (int)result;
79479   return jresult;
79480 }
79481
79482
79483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79484   int jresult ;
79485   int result;
79486
79487   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79488   jresult = (int)result;
79489   return jresult;
79490 }
79491
79492
79493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79494   int jresult ;
79495   int result;
79496
79497   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79498   jresult = (int)result;
79499   return jresult;
79500 }
79501
79502
79503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79504   int jresult ;
79505   int result;
79506
79507   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79508   jresult = (int)result;
79509   return jresult;
79510 }
79511
79512
79513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79514   int jresult ;
79515   int result;
79516
79517   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79518   jresult = (int)result;
79519   return jresult;
79520 }
79521
79522
79523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79524   int jresult ;
79525   int result;
79526
79527   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79528   jresult = (int)result;
79529   return jresult;
79530 }
79531
79532
79533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79534   int jresult ;
79535   int result;
79536
79537   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79538   jresult = (int)result;
79539   return jresult;
79540 }
79541
79542
79543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79544   void * jresult ;
79545   Dali::Toolkit::TextLabel::Property *result = 0 ;
79546
79547   {
79548     try {
79549       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79550     } catch (std::out_of_range& e) {
79551       {
79552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79553       };
79554     } catch (std::exception& e) {
79555       {
79556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79557       };
79558     } catch (...) {
79559       {
79560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79561       };
79562     }
79563   }
79564   jresult = (void *)result;
79565   return jresult;
79566 }
79567
79568
79569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79570   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79571
79572   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79573   {
79574     try {
79575       delete arg1;
79576     } catch (std::out_of_range& e) {
79577       {
79578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79579       };
79580     } catch (std::exception& e) {
79581       {
79582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79583       };
79584     } catch (...) {
79585       {
79586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79587       };
79588     }
79589   }
79590 }
79591
79592
79593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79594   void * jresult ;
79595   Dali::Toolkit::TextLabel result;
79596
79597   {
79598     try {
79599       result = Dali::Toolkit::TextLabel::New();
79600     } catch (std::out_of_range& e) {
79601       {
79602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79603       };
79604     } catch (std::exception& e) {
79605       {
79606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79607       };
79608     } catch (...) {
79609       {
79610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79611       };
79612     }
79613   }
79614   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79615   return jresult;
79616 }
79617
79618
79619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79620   void * jresult ;
79621   std::string *arg1 = 0 ;
79622   Dali::Toolkit::TextLabel result;
79623
79624   if (!jarg1) {
79625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79626     return 0;
79627   }
79628   std::string arg1_str(jarg1);
79629   arg1 = &arg1_str;
79630   {
79631     try {
79632       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79633     } catch (std::out_of_range& e) {
79634       {
79635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79636       };
79637     } catch (std::exception& e) {
79638       {
79639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (...) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79644       };
79645     }
79646   }
79647   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79648
79649   //argout typemap for const std::string&
79650
79651   return jresult;
79652 }
79653
79654
79655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79656   void * jresult ;
79657   Dali::Toolkit::TextLabel *result = 0 ;
79658
79659   {
79660     try {
79661       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79662     } catch (std::out_of_range& e) {
79663       {
79664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79665       };
79666     } catch (std::exception& e) {
79667       {
79668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79669       };
79670     } catch (...) {
79671       {
79672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79673       };
79674     }
79675   }
79676   jresult = (void *)result;
79677   return jresult;
79678 }
79679
79680
79681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79682   void * jresult ;
79683   Dali::Toolkit::TextLabel *arg1 = 0 ;
79684   Dali::Toolkit::TextLabel *result = 0 ;
79685
79686   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79687   if (!arg1) {
79688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79689     return 0;
79690   }
79691   {
79692     try {
79693       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79694     } catch (std::out_of_range& e) {
79695       {
79696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (std::exception& e) {
79699       {
79700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79701       };
79702     } catch (...) {
79703       {
79704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79705       };
79706     }
79707   }
79708   jresult = (void *)result;
79709   return jresult;
79710 }
79711
79712
79713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79714   void * jresult ;
79715   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79716   Dali::Toolkit::TextLabel *arg2 = 0 ;
79717   Dali::Toolkit::TextLabel *result = 0 ;
79718
79719   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79720   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79721   if (!arg2) {
79722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79723     return 0;
79724   }
79725   {
79726     try {
79727       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79728     } catch (std::out_of_range& e) {
79729       {
79730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79731       };
79732     } catch (std::exception& e) {
79733       {
79734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79735       };
79736     } catch (...) {
79737       {
79738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79739       };
79740     }
79741   }
79742   jresult = (void *)result;
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79748   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79749
79750   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79751   {
79752     try {
79753       delete arg1;
79754     } catch (std::out_of_range& e) {
79755       {
79756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79757       };
79758     } catch (std::exception& e) {
79759       {
79760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79761       };
79762     } catch (...) {
79763       {
79764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79765       };
79766     }
79767   }
79768 }
79769
79770
79771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79772   void * jresult ;
79773   Dali::BaseHandle arg1 ;
79774   Dali::BaseHandle *argp1 ;
79775   Dali::Toolkit::TextLabel result;
79776
79777   argp1 = (Dali::BaseHandle *)jarg1;
79778   if (!argp1) {
79779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79780     return 0;
79781   }
79782   arg1 = *argp1;
79783   {
79784     try {
79785       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79786     } catch (std::out_of_range& e) {
79787       {
79788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79789       };
79790     } catch (std::exception& e) {
79791       {
79792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79793       };
79794     } catch (...) {
79795       {
79796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79797       };
79798     }
79799   }
79800   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79801   return jresult;
79802 }
79803
79804
79805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79806   void * jresult ;
79807   Dali::Toolkit::AccessibilityManager *result = 0 ;
79808
79809   {
79810     try {
79811       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79812     } catch (std::out_of_range& e) {
79813       {
79814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79815       };
79816     } catch (std::exception& e) {
79817       {
79818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79819       };
79820     } catch (...) {
79821       {
79822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79823       };
79824     }
79825   }
79826   jresult = (void *)result;
79827   return jresult;
79828 }
79829
79830
79831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79832   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79833
79834   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79835   {
79836     try {
79837       delete arg1;
79838     } catch (std::out_of_range& e) {
79839       {
79840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79841       };
79842     } catch (std::exception& e) {
79843       {
79844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79845       };
79846     } catch (...) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79849       };
79850     }
79851   }
79852 }
79853
79854
79855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79856   void * jresult ;
79857   Dali::Toolkit::AccessibilityManager result;
79858
79859   {
79860     try {
79861       result = Dali::Toolkit::AccessibilityManager::Get();
79862     } catch (std::out_of_range& e) {
79863       {
79864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79865       };
79866     } catch (std::exception& e) {
79867       {
79868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79869       };
79870     } catch (...) {
79871       {
79872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79873       };
79874     }
79875   }
79876   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79877   return jresult;
79878 }
79879
79880
79881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79883   Dali::Actor arg2 ;
79884   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79885   std::string *arg4 = 0 ;
79886   Dali::Actor *argp2 ;
79887
79888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79889   argp2 = (Dali::Actor *)jarg2;
79890   if (!argp2) {
79891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79892     return ;
79893   }
79894   arg2 = *argp2;
79895   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79896   if (!jarg4) {
79897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79898     return ;
79899   }
79900   std::string arg4_str(jarg4);
79901   arg4 = &arg4_str;
79902   {
79903     try {
79904       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79905     } catch (std::out_of_range& e) {
79906       {
79907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79908       };
79909     } catch (std::exception& e) {
79910       {
79911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79912       };
79913     } catch (...) {
79914       {
79915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79916       };
79917     }
79918   }
79919
79920   //argout typemap for const std::string&
79921
79922 }
79923
79924
79925 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79926   char * jresult ;
79927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79928   Dali::Actor arg2 ;
79929   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79930   Dali::Actor *argp2 ;
79931   std::string result;
79932
79933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79934   argp2 = (Dali::Actor *)jarg2;
79935   if (!argp2) {
79936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79937     return 0;
79938   }
79939   arg2 = *argp2;
79940   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79941   {
79942     try {
79943       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79944     } catch (std::out_of_range& e) {
79945       {
79946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79947       };
79948     } catch (std::exception& e) {
79949       {
79950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79951       };
79952     } catch (...) {
79953       {
79954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79955       };
79956     }
79957   }
79958   jresult = SWIG_csharp_string_callback((&result)->c_str());
79959   return jresult;
79960 }
79961
79962
79963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79964   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79965   Dali::Actor arg2 ;
79966   unsigned int arg3 ;
79967   Dali::Actor *argp2 ;
79968
79969   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79970   argp2 = (Dali::Actor *)jarg2;
79971   if (!argp2) {
79972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79973     return ;
79974   }
79975   arg2 = *argp2;
79976   arg3 = (unsigned int)jarg3;
79977   {
79978     try {
79979       (arg1)->SetFocusOrder(arg2,arg3);
79980     } catch (std::out_of_range& e) {
79981       {
79982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79983       };
79984     } catch (std::exception& e) {
79985       {
79986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79987       };
79988     } catch (...) {
79989       {
79990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79991       };
79992     }
79993   }
79994 }
79995
79996
79997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79998   unsigned int jresult ;
79999   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80000   Dali::Actor arg2 ;
80001   Dali::Actor *argp2 ;
80002   unsigned int result;
80003
80004   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80005   argp2 = (Dali::Actor *)jarg2;
80006   if (!argp2) {
80007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80008     return 0;
80009   }
80010   arg2 = *argp2;
80011   {
80012     try {
80013       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
80014     } catch (std::out_of_range& e) {
80015       {
80016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80017       };
80018     } catch (std::exception& e) {
80019       {
80020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80021       };
80022     } catch (...) {
80023       {
80024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80025       };
80026     }
80027   }
80028   jresult = result;
80029   return jresult;
80030 }
80031
80032
80033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80034   unsigned int jresult ;
80035   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80036   unsigned int result;
80037
80038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80039   {
80040     try {
80041       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80042     } catch (std::out_of_range& e) {
80043       {
80044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80045       };
80046     } catch (std::exception& e) {
80047       {
80048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80049       };
80050     } catch (...) {
80051       {
80052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80053       };
80054     }
80055   }
80056   jresult = result;
80057   return jresult;
80058 }
80059
80060
80061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80062   void * jresult ;
80063   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80064   unsigned int arg2 ;
80065   Dali::Actor result;
80066
80067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80068   arg2 = (unsigned int)jarg2;
80069   {
80070     try {
80071       result = (arg1)->GetActorByFocusOrder(arg2);
80072     } catch (std::out_of_range& e) {
80073       {
80074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80075       };
80076     } catch (std::exception& e) {
80077       {
80078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80079       };
80080     } catch (...) {
80081       {
80082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80083       };
80084     }
80085   }
80086   jresult = new Dali::Actor((const Dali::Actor &)result);
80087   return jresult;
80088 }
80089
80090
80091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80092   unsigned int jresult ;
80093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80094   Dali::Actor arg2 ;
80095   Dali::Actor *argp2 ;
80096   bool result;
80097
80098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80099   argp2 = (Dali::Actor *)jarg2;
80100   if (!argp2) {
80101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80102     return 0;
80103   }
80104   arg2 = *argp2;
80105   {
80106     try {
80107       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80108     } catch (std::out_of_range& e) {
80109       {
80110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (std::exception& e) {
80113       {
80114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80115       };
80116     } catch (...) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80119       };
80120     }
80121   }
80122   jresult = result;
80123   return jresult;
80124 }
80125
80126
80127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80128   void * jresult ;
80129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80130   Dali::Actor result;
80131
80132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80133   {
80134     try {
80135       result = (arg1)->GetCurrentFocusActor();
80136     } catch (std::out_of_range& e) {
80137       {
80138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80139       };
80140     } catch (std::exception& e) {
80141       {
80142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80143       };
80144     } catch (...) {
80145       {
80146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80147       };
80148     }
80149   }
80150   jresult = new Dali::Actor((const Dali::Actor &)result);
80151   return jresult;
80152 }
80153
80154
80155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80156   void * jresult ;
80157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80158   Dali::Actor result;
80159
80160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80161   {
80162     try {
80163       result = (arg1)->GetCurrentFocusGroup();
80164     } catch (std::out_of_range& e) {
80165       {
80166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80167       };
80168     } catch (std::exception& e) {
80169       {
80170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80171       };
80172     } catch (...) {
80173       {
80174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80175       };
80176     }
80177   }
80178   jresult = new Dali::Actor((const Dali::Actor &)result);
80179   return jresult;
80180 }
80181
80182
80183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80184   unsigned int jresult ;
80185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80186   unsigned int result;
80187
80188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80189   {
80190     try {
80191       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80192     } catch (std::out_of_range& e) {
80193       {
80194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80195       };
80196     } catch (std::exception& e) {
80197       {
80198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80199       };
80200     } catch (...) {
80201       {
80202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80203       };
80204     }
80205   }
80206   jresult = result;
80207   return jresult;
80208 }
80209
80210
80211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80212   unsigned int jresult ;
80213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80214   bool result;
80215
80216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80217   {
80218     try {
80219       result = (bool)(arg1)->MoveFocusForward();
80220     } catch (std::out_of_range& e) {
80221       {
80222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80223       };
80224     } catch (std::exception& e) {
80225       {
80226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80227       };
80228     } catch (...) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80231       };
80232     }
80233   }
80234   jresult = result;
80235   return jresult;
80236 }
80237
80238
80239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80240   unsigned int jresult ;
80241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80242   bool result;
80243
80244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80245   {
80246     try {
80247       result = (bool)(arg1)->MoveFocusBackward();
80248     } catch (std::out_of_range& e) {
80249       {
80250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80251       };
80252     } catch (std::exception& e) {
80253       {
80254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80255       };
80256     } catch (...) {
80257       {
80258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80259       };
80260     }
80261   }
80262   jresult = result;
80263   return jresult;
80264 }
80265
80266
80267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80269
80270   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80271   {
80272     try {
80273       (arg1)->ClearFocus();
80274     } catch (std::out_of_range& e) {
80275       {
80276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80277       };
80278     } catch (std::exception& e) {
80279       {
80280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80281       };
80282     } catch (...) {
80283       {
80284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80285       };
80286     }
80287   }
80288 }
80289
80290
80291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80292   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80293
80294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80295   {
80296     try {
80297       (arg1)->Reset();
80298     } catch (std::out_of_range& e) {
80299       {
80300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80301       };
80302     } catch (std::exception& e) {
80303       {
80304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80305       };
80306     } catch (...) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80309       };
80310     }
80311   }
80312 }
80313
80314
80315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80316   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80317   Dali::Actor arg2 ;
80318   bool arg3 ;
80319   Dali::Actor *argp2 ;
80320
80321   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80322   argp2 = (Dali::Actor *)jarg2;
80323   if (!argp2) {
80324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80325     return ;
80326   }
80327   arg2 = *argp2;
80328   arg3 = jarg3 ? true : false;
80329   {
80330     try {
80331       (arg1)->SetFocusGroup(arg2,arg3);
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80339       };
80340     } catch (...) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80343       };
80344     }
80345   }
80346 }
80347
80348
80349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80350   unsigned int jresult ;
80351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80352   Dali::Actor arg2 ;
80353   Dali::Actor *argp2 ;
80354   bool result;
80355
80356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80357   argp2 = (Dali::Actor *)jarg2;
80358   if (!argp2) {
80359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80360     return 0;
80361   }
80362   arg2 = *argp2;
80363   {
80364     try {
80365       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80366     } catch (std::out_of_range& e) {
80367       {
80368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80369       };
80370     } catch (std::exception& e) {
80371       {
80372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80373       };
80374     } catch (...) {
80375       {
80376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80377       };
80378     }
80379   }
80380   jresult = result;
80381   return jresult;
80382 }
80383
80384
80385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80386   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80387   bool arg2 ;
80388
80389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80390   arg2 = jarg2 ? true : false;
80391   {
80392     try {
80393       (arg1)->SetGroupMode(arg2);
80394     } catch (std::out_of_range& e) {
80395       {
80396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80397       };
80398     } catch (std::exception& e) {
80399       {
80400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80401       };
80402     } catch (...) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80405       };
80406     }
80407   }
80408 }
80409
80410
80411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80412   unsigned int jresult ;
80413   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80414   bool result;
80415
80416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80417   {
80418     try {
80419       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80427       };
80428     } catch (...) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80431       };
80432     }
80433   }
80434   jresult = result;
80435   return jresult;
80436 }
80437
80438
80439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80440   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80441   bool arg2 ;
80442
80443   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80444   arg2 = jarg2 ? true : false;
80445   {
80446     try {
80447       (arg1)->SetWrapMode(arg2);
80448     } catch (std::out_of_range& e) {
80449       {
80450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80451       };
80452     } catch (std::exception& e) {
80453       {
80454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80455       };
80456     } catch (...) {
80457       {
80458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80459       };
80460     }
80461   }
80462 }
80463
80464
80465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80466   unsigned int jresult ;
80467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80468   bool result;
80469
80470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80471   {
80472     try {
80473       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80474     } catch (std::out_of_range& e) {
80475       {
80476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80477       };
80478     } catch (std::exception& e) {
80479       {
80480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80481       };
80482     } catch (...) {
80483       {
80484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80485       };
80486     }
80487   }
80488   jresult = result;
80489   return jresult;
80490 }
80491
80492
80493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80494   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80495   Dali::Actor arg2 ;
80496   Dali::Actor *argp2 ;
80497
80498   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80499   argp2 = (Dali::Actor *)jarg2;
80500   if (!argp2) {
80501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80502     return ;
80503   }
80504   arg2 = *argp2;
80505   {
80506     try {
80507       (arg1)->SetFocusIndicatorActor(arg2);
80508     } catch (std::out_of_range& e) {
80509       {
80510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80511       };
80512     } catch (std::exception& e) {
80513       {
80514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80515       };
80516     } catch (...) {
80517       {
80518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80519       };
80520     }
80521   }
80522 }
80523
80524
80525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80526   void * jresult ;
80527   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80528   Dali::Actor result;
80529
80530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80531   {
80532     try {
80533       result = (arg1)->GetFocusIndicatorActor();
80534     } catch (std::out_of_range& e) {
80535       {
80536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80537       };
80538     } catch (std::exception& e) {
80539       {
80540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80541       };
80542     } catch (...) {
80543       {
80544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80545       };
80546     }
80547   }
80548   jresult = new Dali::Actor((const Dali::Actor &)result);
80549   return jresult;
80550 }
80551
80552
80553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80554   void * jresult ;
80555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80556   Dali::Actor arg2 ;
80557   Dali::Actor *argp2 ;
80558   Dali::Actor result;
80559
80560   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80561   argp2 = (Dali::Actor *)jarg2;
80562   if (!argp2) {
80563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80564     return 0;
80565   }
80566   arg2 = *argp2;
80567   {
80568     try {
80569       result = (arg1)->GetFocusGroup(arg2);
80570     } catch (std::out_of_range& e) {
80571       {
80572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80573       };
80574     } catch (std::exception& e) {
80575       {
80576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80577       };
80578     } catch (...) {
80579       {
80580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80581       };
80582     }
80583   }
80584   jresult = new Dali::Actor((const Dali::Actor &)result);
80585   return jresult;
80586 }
80587
80588
80589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80590   void * jresult ;
80591   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80592   Dali::Vector2 result;
80593
80594   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80595   {
80596     try {
80597       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80598     } catch (std::out_of_range& e) {
80599       {
80600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80601       };
80602     } catch (std::exception& e) {
80603       {
80604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80605       };
80606     } catch (...) {
80607       {
80608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80609       };
80610     }
80611   }
80612   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80613   return jresult;
80614 }
80615
80616
80617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80618   void * jresult ;
80619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80620   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80621
80622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80623   {
80624     try {
80625       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80626     } catch (std::out_of_range& e) {
80627       {
80628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80629       };
80630     } catch (std::exception& e) {
80631       {
80632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80633       };
80634     } catch (...) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80637       };
80638     }
80639   }
80640   jresult = (void *)result;
80641   return jresult;
80642 }
80643
80644
80645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80646   void * jresult ;
80647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80648   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80649
80650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80651   {
80652     try {
80653       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80654     } catch (std::out_of_range& e) {
80655       {
80656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80657       };
80658     } catch (std::exception& e) {
80659       {
80660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80661       };
80662     } catch (...) {
80663       {
80664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80665       };
80666     }
80667   }
80668   jresult = (void *)result;
80669   return jresult;
80670 }
80671
80672
80673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80674   void * jresult ;
80675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80676   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80677
80678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80679   {
80680     try {
80681       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80682     } catch (std::out_of_range& e) {
80683       {
80684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80685       };
80686     } catch (std::exception& e) {
80687       {
80688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80689       };
80690     } catch (...) {
80691       {
80692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80693       };
80694     }
80695   }
80696   jresult = (void *)result;
80697   return jresult;
80698 }
80699
80700
80701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80702   void * jresult ;
80703   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80704   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80705
80706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80707   {
80708     try {
80709       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80710     } catch (std::out_of_range& e) {
80711       {
80712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80713       };
80714     } catch (std::exception& e) {
80715       {
80716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80717       };
80718     } catch (...) {
80719       {
80720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80721       };
80722     }
80723   }
80724   jresult = (void *)result;
80725   return jresult;
80726 }
80727
80728
80729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80730   void * jresult ;
80731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80732   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80733
80734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80735   {
80736     try {
80737       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80738     } catch (std::out_of_range& e) {
80739       {
80740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80741       };
80742     } catch (std::exception& e) {
80743       {
80744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80745       };
80746     } catch (...) {
80747       {
80748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80749       };
80750     }
80751   }
80752   jresult = (void *)result;
80753   return jresult;
80754 }
80755
80756
80757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80758   void * jresult ;
80759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80760   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80761
80762   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80763   {
80764     try {
80765       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80766     } catch (std::out_of_range& e) {
80767       {
80768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80769       };
80770     } catch (std::exception& e) {
80771       {
80772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80773       };
80774     } catch (...) {
80775       {
80776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80777       };
80778     }
80779   }
80780   jresult = (void *)result;
80781   return jresult;
80782 }
80783
80784
80785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80786   void * jresult ;
80787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80789
80790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80791   {
80792     try {
80793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80794     } catch (std::out_of_range& e) {
80795       {
80796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80797       };
80798     } catch (std::exception& e) {
80799       {
80800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80801       };
80802     } catch (...) {
80803       {
80804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80805       };
80806     }
80807   }
80808   jresult = (void *)result;
80809   return jresult;
80810 }
80811
80812
80813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80814   void * jresult ;
80815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80816   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80817
80818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80819   {
80820     try {
80821       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80822     } catch (std::out_of_range& e) {
80823       {
80824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80825       };
80826     } catch (std::exception& e) {
80827       {
80828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80829       };
80830     } catch (...) {
80831       {
80832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80833       };
80834     }
80835   }
80836   jresult = (void *)result;
80837   return jresult;
80838 }
80839
80840
80841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80842   void * jresult ;
80843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80844   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80845
80846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80847   {
80848     try {
80849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80850     } catch (std::out_of_range& e) {
80851       {
80852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80853       };
80854     } catch (std::exception& e) {
80855       {
80856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80857       };
80858     } catch (...) {
80859       {
80860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80861       };
80862     }
80863   }
80864   jresult = (void *)result;
80865   return jresult;
80866 }
80867
80868
80869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80870   void * jresult ;
80871   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80872   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80873
80874   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80875   {
80876     try {
80877       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80878     } catch (std::out_of_range& e) {
80879       {
80880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80881       };
80882     } catch (std::exception& e) {
80883       {
80884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80885       };
80886     } catch (...) {
80887       {
80888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80889       };
80890     }
80891   }
80892   jresult = (void *)result;
80893   return jresult;
80894 }
80895
80896
80897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80898   void * jresult ;
80899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80900   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80901
80902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80903   {
80904     try {
80905       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80906     } catch (std::out_of_range& e) {
80907       {
80908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80909       };
80910     } catch (std::exception& e) {
80911       {
80912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80913       };
80914     } catch (...) {
80915       {
80916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80917       };
80918     }
80919   }
80920   jresult = (void *)result;
80921   return jresult;
80922 }
80923
80924
80925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80926   void * jresult ;
80927   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80928   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80929
80930   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80931   {
80932     try {
80933       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80934     } catch (std::out_of_range& e) {
80935       {
80936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80937       };
80938     } catch (std::exception& e) {
80939       {
80940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80941       };
80942     } catch (...) {
80943       {
80944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80945       };
80946     }
80947   }
80948   jresult = (void *)result;
80949   return jresult;
80950 }
80951
80952
80953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80954   void * jresult ;
80955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80956   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80957
80958   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80959   {
80960     try {
80961       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80962     } catch (std::out_of_range& e) {
80963       {
80964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80965       };
80966     } catch (std::exception& e) {
80967       {
80968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80969       };
80970     } catch (...) {
80971       {
80972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80973       };
80974     }
80975   }
80976   jresult = (void *)result;
80977   return jresult;
80978 }
80979
80980
80981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80982   void * jresult ;
80983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80984   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80985
80986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80987   {
80988     try {
80989       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80990     } catch (std::out_of_range& e) {
80991       {
80992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80993       };
80994     } catch (std::exception& e) {
80995       {
80996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80997       };
80998     } catch (...) {
80999       {
81000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81001       };
81002     }
81003   }
81004   jresult = (void *)result;
81005   return jresult;
81006 }
81007
81008
81009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81010   void * jresult ;
81011   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81012   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81013
81014   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81015   {
81016     try {
81017       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81018     } catch (std::out_of_range& e) {
81019       {
81020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81021       };
81022     } catch (std::exception& e) {
81023       {
81024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81025       };
81026     } catch (...) {
81027       {
81028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81029       };
81030     }
81031   }
81032   jresult = (void *)result;
81033   return jresult;
81034 }
81035
81036
81037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81038   void * jresult ;
81039   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81040   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81041
81042   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81043   {
81044     try {
81045       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81046     } catch (std::out_of_range& e) {
81047       {
81048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81049       };
81050     } catch (std::exception& e) {
81051       {
81052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81053       };
81054     } catch (...) {
81055       {
81056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81057       };
81058     }
81059   }
81060   jresult = (void *)result;
81061   return jresult;
81062 }
81063
81064
81065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81066   void * jresult ;
81067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81068   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81069
81070   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81071   {
81072     try {
81073       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81074     } catch (std::out_of_range& e) {
81075       {
81076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81077       };
81078     } catch (std::exception& e) {
81079       {
81080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81081       };
81082     } catch (...) {
81083       {
81084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81085       };
81086     }
81087   }
81088   jresult = (void *)result;
81089   return jresult;
81090 }
81091
81092
81093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81094   void * jresult ;
81095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81096   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81097
81098   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81099   {
81100     try {
81101       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81102     } catch (std::out_of_range& e) {
81103       {
81104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81105       };
81106     } catch (std::exception& e) {
81107       {
81108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81109       };
81110     } catch (...) {
81111       {
81112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81113       };
81114     }
81115   }
81116   jresult = (void *)result;
81117   return jresult;
81118 }
81119
81120
81121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81122   void * jresult ;
81123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81125
81126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81127   {
81128     try {
81129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81130     } catch (std::out_of_range& e) {
81131       {
81132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81133       };
81134     } catch (std::exception& e) {
81135       {
81136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81137       };
81138     } catch (...) {
81139       {
81140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81141       };
81142     }
81143   }
81144   jresult = (void *)result;
81145   return jresult;
81146 }
81147
81148
81149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81150   void * jresult ;
81151   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81152   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81153
81154   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81155   {
81156     try {
81157       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81158     } catch (std::out_of_range& e) {
81159       {
81160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81161       };
81162     } catch (std::exception& e) {
81163       {
81164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81165       };
81166     } catch (...) {
81167       {
81168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81169       };
81170     }
81171   }
81172   jresult = (void *)result;
81173   return jresult;
81174 }
81175
81176
81177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81178   void * jresult ;
81179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81180   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81181
81182   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81183   {
81184     try {
81185       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81186     } catch (std::out_of_range& e) {
81187       {
81188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81189       };
81190     } catch (std::exception& e) {
81191       {
81192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81197       };
81198     }
81199   }
81200   jresult = (void *)result;
81201   return jresult;
81202 }
81203
81204
81205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81206   void * jresult ;
81207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81208   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81209
81210   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81211   {
81212     try {
81213       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81214     } catch (std::out_of_range& e) {
81215       {
81216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81217       };
81218     } catch (std::exception& e) {
81219       {
81220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81221       };
81222     } catch (...) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81225       };
81226     }
81227   }
81228   jresult = (void *)result;
81229   return jresult;
81230 }
81231
81232
81233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81234   void * jresult ;
81235   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81236   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81237
81238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81239   {
81240     try {
81241       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81242     } catch (std::out_of_range& e) {
81243       {
81244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81245       };
81246     } catch (std::exception& e) {
81247       {
81248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81249       };
81250     } catch (...) {
81251       {
81252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81253       };
81254     }
81255   }
81256   jresult = (void *)result;
81257   return jresult;
81258 }
81259
81260
81261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81262   void * jresult ;
81263   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81264   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81265
81266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81267   {
81268     try {
81269       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81270     } catch (std::out_of_range& e) {
81271       {
81272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81273       };
81274     } catch (std::exception& e) {
81275       {
81276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81277       };
81278     } catch (...) {
81279       {
81280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81281       };
81282     }
81283   }
81284   jresult = (void *)result;
81285   return jresult;
81286 }
81287
81288
81289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81290   void * jresult ;
81291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81292   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81293
81294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81295   {
81296     try {
81297       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81298     } catch (std::out_of_range& e) {
81299       {
81300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81301       };
81302     } catch (std::exception& e) {
81303       {
81304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81305       };
81306     } catch (...) {
81307       {
81308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81309       };
81310     }
81311   }
81312   jresult = (void *)result;
81313   return jresult;
81314 }
81315
81316
81317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81318   void * jresult ;
81319   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81320   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81321
81322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81323   {
81324     try {
81325       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81326     } catch (std::out_of_range& e) {
81327       {
81328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81329       };
81330     } catch (std::exception& e) {
81331       {
81332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81333       };
81334     } catch (...) {
81335       {
81336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81337       };
81338     }
81339   }
81340   jresult = (void *)result;
81341   return jresult;
81342 }
81343
81344
81345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81346   void * jresult ;
81347   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81348   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81349
81350   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81351   {
81352     try {
81353       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81354     } catch (std::out_of_range& e) {
81355       {
81356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81357       };
81358     } catch (std::exception& e) {
81359       {
81360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81361       };
81362     } catch (...) {
81363       {
81364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81365       };
81366     }
81367   }
81368   jresult = (void *)result;
81369   return jresult;
81370 }
81371
81372
81373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81374   void * jresult ;
81375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81377
81378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81379   {
81380     try {
81381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81382     } catch (std::out_of_range& e) {
81383       {
81384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81385       };
81386     } catch (std::exception& e) {
81387       {
81388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (...) {
81391       {
81392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81393       };
81394     }
81395   }
81396   jresult = (void *)result;
81397   return jresult;
81398 }
81399
81400
81401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81402   void * jresult ;
81403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81404   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81405
81406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81407   {
81408     try {
81409       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81417       };
81418     } catch (...) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81421       };
81422     }
81423   }
81424   jresult = (void *)result;
81425   return jresult;
81426 }
81427
81428
81429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81430   void * jresult ;
81431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81432   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81433
81434   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81435   {
81436     try {
81437       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81438     } catch (std::out_of_range& e) {
81439       {
81440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81441       };
81442     } catch (std::exception& e) {
81443       {
81444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81445       };
81446     } catch (...) {
81447       {
81448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81449       };
81450     }
81451   }
81452   jresult = (void *)result;
81453   return jresult;
81454 }
81455
81456
81457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81458   void * jresult ;
81459   Dali::Toolkit::StyleManager *result = 0 ;
81460
81461   {
81462     try {
81463       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81464     } catch (std::out_of_range& e) {
81465       {
81466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81467       };
81468     } catch (std::exception& e) {
81469       {
81470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81471       };
81472     } catch (...) {
81473       {
81474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81475       };
81476     }
81477   }
81478   jresult = (void *)result;
81479   return jresult;
81480 }
81481
81482
81483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81484   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81485
81486   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81487   {
81488     try {
81489       delete arg1;
81490     } catch (std::out_of_range& e) {
81491       {
81492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81493       };
81494     } catch (std::exception& e) {
81495       {
81496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81497       };
81498     } catch (...) {
81499       {
81500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81501       };
81502     }
81503   }
81504 }
81505
81506
81507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81508   void * jresult ;
81509   Dali::Toolkit::StyleManager result;
81510
81511   {
81512     try {
81513       result = Dali::Toolkit::StyleManager::Get();
81514     } catch (std::out_of_range& e) {
81515       {
81516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81517       };
81518     } catch (std::exception& e) {
81519       {
81520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81521       };
81522     } catch (...) {
81523       {
81524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81525       };
81526     }
81527   }
81528   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81529   return jresult;
81530 }
81531
81532
81533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81534   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81535   std::string *arg2 = 0 ;
81536
81537   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81538   if (!jarg2) {
81539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81540     return ;
81541   }
81542   std::string arg2_str(jarg2);
81543   arg2 = &arg2_str;
81544   {
81545     try {
81546       (arg1)->ApplyTheme((std::string const &)*arg2);
81547     } catch (std::out_of_range& e) {
81548       {
81549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81550       };
81551     } catch (std::exception& e) {
81552       {
81553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81554       };
81555     } catch (...) {
81556       {
81557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81558       };
81559     }
81560   }
81561
81562   //argout typemap for const std::string&
81563
81564 }
81565
81566
81567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81568   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81569
81570   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81571   {
81572     try {
81573       (arg1)->ApplyDefaultTheme();
81574     } catch (std::out_of_range& e) {
81575       {
81576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81577       };
81578     } catch (std::exception& e) {
81579       {
81580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81581       };
81582     } catch (...) {
81583       {
81584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81585       };
81586     }
81587   }
81588 }
81589
81590
81591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81592   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81593   std::string *arg2 = 0 ;
81594   Dali::Property::Value *arg3 = 0 ;
81595
81596   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81597   if (!jarg2) {
81598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81599     return ;
81600   }
81601   std::string arg2_str(jarg2);
81602   arg2 = &arg2_str;
81603   arg3 = (Dali::Property::Value *)jarg3;
81604   if (!arg3) {
81605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81606     return ;
81607   }
81608   {
81609     try {
81610       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81611     } catch (std::out_of_range& e) {
81612       {
81613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81614       };
81615     } catch (std::exception& e) {
81616       {
81617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81618       };
81619     } catch (...) {
81620       {
81621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81622       };
81623     }
81624   }
81625
81626   //argout typemap for const std::string&
81627
81628 }
81629
81630
81631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81632   unsigned int jresult ;
81633   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81634   std::string *arg2 = 0 ;
81635   Dali::Property::Value *arg3 = 0 ;
81636   bool result;
81637
81638   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81639   if (!jarg2) {
81640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81641     return 0;
81642   }
81643   std::string arg2_str(jarg2);
81644   arg2 = &arg2_str;
81645   arg3 = (Dali::Property::Value *)jarg3;
81646   if (!arg3) {
81647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81648     return 0;
81649   }
81650   {
81651     try {
81652       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81653     } catch (std::out_of_range& e) {
81654       {
81655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81656       };
81657     } catch (std::exception& e) {
81658       {
81659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81660       };
81661     } catch (...) {
81662       {
81663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81664       };
81665     }
81666   }
81667   jresult = result;
81668
81669   //argout typemap for const std::string&
81670
81671   return jresult;
81672 }
81673
81674
81675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81676   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81677   Dali::Toolkit::Control arg2 ;
81678   std::string *arg3 = 0 ;
81679   std::string *arg4 = 0 ;
81680   Dali::Toolkit::Control *argp2 ;
81681
81682   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81683   argp2 = (Dali::Toolkit::Control *)jarg2;
81684   if (!argp2) {
81685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81686     return ;
81687   }
81688   arg2 = *argp2;
81689   if (!jarg3) {
81690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81691     return ;
81692   }
81693   std::string arg3_str(jarg3);
81694   arg3 = &arg3_str;
81695   if (!jarg4) {
81696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81697     return ;
81698   }
81699   std::string arg4_str(jarg4);
81700   arg4 = &arg4_str;
81701   {
81702     try {
81703       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81711       };
81712     } catch (...) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81715       };
81716     }
81717   }
81718
81719   //argout typemap for const std::string&
81720
81721
81722   //argout typemap for const std::string&
81723
81724 }
81725
81726
81727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81728   void * jresult ;
81729   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81730   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81731
81732   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81733   {
81734     try {
81735       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81736     } catch (std::out_of_range& e) {
81737       {
81738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81739       };
81740     } catch (std::exception& e) {
81741       {
81742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81743       };
81744     } catch (...) {
81745       {
81746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81747       };
81748     }
81749   }
81750   jresult = (void *)result;
81751   return jresult;
81752 }
81753
81754
81755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81756   int jresult ;
81757   int result;
81758
81759   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81760   jresult = (int)result;
81761   return jresult;
81762 }
81763
81764
81765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81766   int jresult ;
81767   int result;
81768
81769   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81770   jresult = (int)result;
81771   return jresult;
81772 }
81773
81774
81775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81776   int jresult ;
81777   int result;
81778
81779   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81780   jresult = (int)result;
81781   return jresult;
81782 }
81783
81784
81785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81786   int jresult ;
81787   int result;
81788
81789   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81790   jresult = (int)result;
81791   return jresult;
81792 }
81793
81794
81795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81796   int jresult ;
81797   int result;
81798
81799   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81800   jresult = (int)result;
81801   return jresult;
81802 }
81803
81804
81805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81806   int jresult ;
81807   int result;
81808
81809   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81810   jresult = (int)result;
81811   return jresult;
81812 }
81813
81814
81815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81816   int jresult ;
81817   int result;
81818
81819   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81820   jresult = (int)result;
81821   return jresult;
81822 }
81823
81824
81825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81826   int jresult ;
81827   int result;
81828
81829   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81830   jresult = (int)result;
81831   return jresult;
81832 }
81833
81834
81835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81836   int jresult ;
81837   int result;
81838
81839   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81840   jresult = (int)result;
81841   return jresult;
81842 }
81843
81844
81845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81846   int jresult ;
81847   int result;
81848
81849   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81850   jresult = (int)result;
81851   return jresult;
81852 }
81853
81854
81855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81856   int jresult ;
81857   int result;
81858
81859   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81860   jresult = (int)result;
81861   return jresult;
81862 }
81863
81864
81865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81866   int jresult ;
81867   int result;
81868
81869   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81870   jresult = (int)result;
81871   return jresult;
81872 }
81873
81874
81875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81876   int jresult ;
81877   int result;
81878
81879   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81880   jresult = (int)result;
81881   return jresult;
81882 }
81883
81884
81885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81886   int jresult ;
81887   int result;
81888
81889   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81890   jresult = (int)result;
81891   return jresult;
81892 }
81893
81894
81895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81896   int jresult ;
81897   int result;
81898
81899   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81900   jresult = (int)result;
81901   return jresult;
81902 }
81903
81904
81905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81906   void * jresult ;
81907   Dali::Toolkit::Slider::Property *result = 0 ;
81908
81909   {
81910     try {
81911       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81912     } catch (std::out_of_range& e) {
81913       {
81914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81915       };
81916     } catch (std::exception& e) {
81917       {
81918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81919       };
81920     } catch (...) {
81921       {
81922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81923       };
81924     }
81925   }
81926   jresult = (void *)result;
81927   return jresult;
81928 }
81929
81930
81931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81932   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81933
81934   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81935   {
81936     try {
81937       delete arg1;
81938     } catch (std::out_of_range& e) {
81939       {
81940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81941       };
81942     } catch (std::exception& e) {
81943       {
81944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81945       };
81946     } catch (...) {
81947       {
81948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81949       };
81950     }
81951   }
81952 }
81953
81954
81955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81956   void * jresult ;
81957   Dali::Toolkit::Slider result;
81958
81959   {
81960     try {
81961       result = Dali::Toolkit::Slider::New();
81962     } catch (std::out_of_range& e) {
81963       {
81964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81965       };
81966     } catch (std::exception& e) {
81967       {
81968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81969       };
81970     } catch (...) {
81971       {
81972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81973       };
81974     }
81975   }
81976   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81977   return jresult;
81978 }
81979
81980
81981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81982   void * jresult ;
81983   Dali::Toolkit::Slider *result = 0 ;
81984
81985   {
81986     try {
81987       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81988     } catch (std::out_of_range& e) {
81989       {
81990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81991       };
81992     } catch (std::exception& e) {
81993       {
81994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81995       };
81996     } catch (...) {
81997       {
81998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81999       };
82000     }
82001   }
82002   jresult = (void *)result;
82003   return jresult;
82004 }
82005
82006
82007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
82008   void * jresult ;
82009   Dali::Toolkit::Slider *arg1 = 0 ;
82010   Dali::Toolkit::Slider *result = 0 ;
82011
82012   arg1 = (Dali::Toolkit::Slider *)jarg1;
82013   if (!arg1) {
82014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82015     return 0;
82016   }
82017   {
82018     try {
82019       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
82020     } catch (std::out_of_range& e) {
82021       {
82022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82023       };
82024     } catch (std::exception& e) {
82025       {
82026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82027       };
82028     } catch (...) {
82029       {
82030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82031       };
82032     }
82033   }
82034   jresult = (void *)result;
82035   return jresult;
82036 }
82037
82038
82039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82040   void * jresult ;
82041   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82042   Dali::Toolkit::Slider *arg2 = 0 ;
82043   Dali::Toolkit::Slider *result = 0 ;
82044
82045   arg1 = (Dali::Toolkit::Slider *)jarg1;
82046   arg2 = (Dali::Toolkit::Slider *)jarg2;
82047   if (!arg2) {
82048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82049     return 0;
82050   }
82051   {
82052     try {
82053       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82054     } catch (std::out_of_range& e) {
82055       {
82056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82057       };
82058     } catch (std::exception& e) {
82059       {
82060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82061       };
82062     } catch (...) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82065       };
82066     }
82067   }
82068   jresult = (void *)result;
82069   return jresult;
82070 }
82071
82072
82073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82074   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82075
82076   arg1 = (Dali::Toolkit::Slider *)jarg1;
82077   {
82078     try {
82079       delete arg1;
82080     } catch (std::out_of_range& e) {
82081       {
82082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82083       };
82084     } catch (std::exception& e) {
82085       {
82086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82087       };
82088     } catch (...) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82091       };
82092     }
82093   }
82094 }
82095
82096
82097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82098   void * jresult ;
82099   Dali::BaseHandle arg1 ;
82100   Dali::BaseHandle *argp1 ;
82101   Dali::Toolkit::Slider result;
82102
82103   argp1 = (Dali::BaseHandle *)jarg1;
82104   if (!argp1) {
82105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82106     return 0;
82107   }
82108   arg1 = *argp1;
82109   {
82110     try {
82111       result = Dali::Toolkit::Slider::DownCast(arg1);
82112     } catch (std::out_of_range& e) {
82113       {
82114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82115       };
82116     } catch (std::exception& e) {
82117       {
82118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82119       };
82120     } catch (...) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82123       };
82124     }
82125   }
82126   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82127   return jresult;
82128 }
82129
82130
82131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82132   void * jresult ;
82133   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82134   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82135
82136   arg1 = (Dali::Toolkit::Slider *)jarg1;
82137   {
82138     try {
82139       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82140     } catch (std::out_of_range& e) {
82141       {
82142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82143       };
82144     } catch (std::exception& e) {
82145       {
82146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82147       };
82148     } catch (...) {
82149       {
82150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82151       };
82152     }
82153   }
82154   jresult = (void *)result;
82155   return jresult;
82156 }
82157
82158
82159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82160   void * jresult ;
82161   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82162   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82163
82164   arg1 = (Dali::Toolkit::Slider *)jarg1;
82165   {
82166     try {
82167       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82168     } catch (std::out_of_range& e) {
82169       {
82170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82171       };
82172     } catch (std::exception& e) {
82173       {
82174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82175       };
82176     } catch (...) {
82177       {
82178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82179       };
82180     }
82181   }
82182   jresult = (void *)result;
82183   return jresult;
82184 }
82185
82186
82187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82188   void * jresult ;
82189   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82190   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82191
82192   arg1 = (Dali::Toolkit::Slider *)jarg1;
82193   {
82194     try {
82195       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82196     } catch (std::out_of_range& e) {
82197       {
82198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82199       };
82200     } catch (std::exception& e) {
82201       {
82202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82207       };
82208     }
82209   }
82210   jresult = (void *)result;
82211   return jresult;
82212 }
82213
82214
82215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82216   int jresult ;
82217   int result;
82218
82219   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82220   jresult = (int)result;
82221   return jresult;
82222 }
82223
82224
82225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82226   int jresult ;
82227   int result;
82228
82229   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82230   jresult = (int)result;
82231   return jresult;
82232 }
82233
82234
82235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82236   int jresult ;
82237   int result;
82238
82239   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82240   jresult = (int)result;
82241   return jresult;
82242 }
82243
82244
82245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82246   int jresult ;
82247   int result;
82248
82249   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82250   jresult = (int)result;
82251   return jresult;
82252 }
82253
82254
82255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82256   void * jresult ;
82257   Dali::Toolkit::VideoView::Property *result = 0 ;
82258
82259   {
82260     try {
82261       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82262     } catch (std::out_of_range& e) {
82263       {
82264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (std::exception& e) {
82267       {
82268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82273       };
82274     }
82275   }
82276   jresult = (void *)result;
82277   return jresult;
82278 }
82279
82280
82281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82282   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82283
82284   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82285   {
82286     try {
82287       delete arg1;
82288     } catch (std::out_of_range& e) {
82289       {
82290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82291       };
82292     } catch (std::exception& e) {
82293       {
82294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82295       };
82296     } catch (...) {
82297       {
82298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82299       };
82300     }
82301   }
82302 }
82303
82304
82305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82306   void * jresult ;
82307   Dali::Toolkit::VideoView result;
82308
82309   {
82310     try {
82311       result = Dali::Toolkit::VideoView::New();
82312     } catch (std::out_of_range& e) {
82313       {
82314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82315       };
82316     } catch (std::exception& e) {
82317       {
82318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82319       };
82320     } catch (...) {
82321       {
82322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82323       };
82324     }
82325   }
82326   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82327   return jresult;
82328 }
82329
82330
82331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82332   void * jresult ;
82333   std::string *arg1 = 0 ;
82334   Dali::Toolkit::VideoView result;
82335
82336   if (!jarg1) {
82337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82338     return 0;
82339   }
82340   std::string arg1_str(jarg1);
82341   arg1 = &arg1_str;
82342   {
82343     try {
82344       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82345     } catch (std::out_of_range& e) {
82346       {
82347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82348       };
82349     } catch (std::exception& e) {
82350       {
82351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82352       };
82353     } catch (...) {
82354       {
82355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82356       };
82357     }
82358   }
82359   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82360
82361   //argout typemap for const std::string&
82362
82363   return jresult;
82364 }
82365
82366
82367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82368   void * jresult ;
82369   Dali::Toolkit::VideoView *result = 0 ;
82370
82371   {
82372     try {
82373       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82374     } catch (std::out_of_range& e) {
82375       {
82376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82377       };
82378     } catch (std::exception& e) {
82379       {
82380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82381       };
82382     } catch (...) {
82383       {
82384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82385       };
82386     }
82387   }
82388   jresult = (void *)result;
82389   return jresult;
82390 }
82391
82392
82393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82394   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82395
82396   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82397   {
82398     try {
82399       delete arg1;
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82407       };
82408     } catch (...) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82411       };
82412     }
82413   }
82414 }
82415
82416
82417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82418   void * jresult ;
82419   Dali::Toolkit::VideoView *arg1 = 0 ;
82420   Dali::Toolkit::VideoView *result = 0 ;
82421
82422   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82423   if (!arg1) {
82424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82425     return 0;
82426   }
82427   {
82428     try {
82429       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82430     } catch (std::out_of_range& e) {
82431       {
82432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82433       };
82434     } catch (std::exception& e) {
82435       {
82436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82437       };
82438     } catch (...) {
82439       {
82440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82441       };
82442     }
82443   }
82444   jresult = (void *)result;
82445   return jresult;
82446 }
82447
82448
82449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82450   void * jresult ;
82451   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82452   Dali::Toolkit::VideoView *arg2 = 0 ;
82453   Dali::Toolkit::VideoView *result = 0 ;
82454
82455   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82456   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82457   if (!arg2) {
82458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82459     return 0;
82460   }
82461   {
82462     try {
82463       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (...) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82475       };
82476     }
82477   }
82478   jresult = (void *)result;
82479   return jresult;
82480 }
82481
82482
82483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82484   void * jresult ;
82485   Dali::BaseHandle arg1 ;
82486   Dali::BaseHandle *argp1 ;
82487   Dali::Toolkit::VideoView result;
82488
82489   argp1 = (Dali::BaseHandle *)jarg1;
82490   if (!argp1) {
82491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82492     return 0;
82493   }
82494   arg1 = *argp1;
82495   {
82496     try {
82497       result = Dali::Toolkit::VideoView::DownCast(arg1);
82498     } catch (std::out_of_range& e) {
82499       {
82500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82501       };
82502     } catch (std::exception& e) {
82503       {
82504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82505       };
82506     } catch (...) {
82507       {
82508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82509       };
82510     }
82511   }
82512   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82513   return jresult;
82514 }
82515
82516
82517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82518   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82519
82520   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82521   {
82522     try {
82523       (arg1)->Play();
82524     } catch (std::out_of_range& e) {
82525       {
82526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82527       };
82528     } catch (std::exception& e) {
82529       {
82530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82531       };
82532     } catch (...) {
82533       {
82534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82535       };
82536     }
82537   }
82538 }
82539
82540
82541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82542   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82543
82544   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82545   {
82546     try {
82547       (arg1)->Pause();
82548     } catch (std::out_of_range& e) {
82549       {
82550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82551       };
82552     } catch (std::exception& e) {
82553       {
82554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82555       };
82556     } catch (...) {
82557       {
82558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82559       };
82560     }
82561   }
82562 }
82563
82564
82565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82566   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82567
82568   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82569   {
82570     try {
82571       (arg1)->Stop();
82572     } catch (std::out_of_range& e) {
82573       {
82574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82575       };
82576     } catch (std::exception& e) {
82577       {
82578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82579       };
82580     } catch (...) {
82581       {
82582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82583       };
82584     }
82585   }
82586 }
82587
82588
82589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82590   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82591   int arg2 ;
82592
82593   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82594   arg2 = (int)jarg2;
82595   {
82596     try {
82597       (arg1)->Forward(arg2);
82598     } catch (std::out_of_range& e) {
82599       {
82600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82601       };
82602     } catch (std::exception& e) {
82603       {
82604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82605       };
82606     } catch (...) {
82607       {
82608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82609       };
82610     }
82611   }
82612 }
82613
82614
82615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82616   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82617   int arg2 ;
82618
82619   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82620   arg2 = (int)jarg2;
82621   {
82622     try {
82623       (arg1)->Backward(arg2);
82624     } catch (std::out_of_range& e) {
82625       {
82626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82627       };
82628     } catch (std::exception& e) {
82629       {
82630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82631       };
82632     } catch (...) {
82633       {
82634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82635       };
82636     }
82637   }
82638 }
82639
82640
82641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82642   void * jresult ;
82643   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82644   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82645
82646   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82647   {
82648     try {
82649       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82657       };
82658     } catch (...) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82661       };
82662     }
82663   }
82664   jresult = (void *)result;
82665   return jresult;
82666 }
82667
82668
82669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82670   int jresult ;
82671   int result;
82672
82673   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82674   jresult = (int)result;
82675   return jresult;
82676 }
82677
82678
82679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82680   int jresult ;
82681   int result;
82682
82683   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82684   jresult = (int)result;
82685   return jresult;
82686 }
82687
82688
82689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82690   int jresult ;
82691   int result;
82692
82693   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82694   jresult = (int)result;
82695   return jresult;
82696 }
82697
82698
82699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82700   int jresult ;
82701   int result;
82702
82703   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82704   jresult = (int)result;
82705   return jresult;
82706 }
82707
82708
82709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82710   int jresult ;
82711   int result;
82712
82713   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82714   jresult = (int)result;
82715   return jresult;
82716 }
82717
82718
82719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82720   int jresult ;
82721   int result;
82722
82723   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82724   jresult = (int)result;
82725   return jresult;
82726 }
82727
82728
82729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82730   int jresult ;
82731   int result;
82732
82733   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82734   jresult = (int)result;
82735   return jresult;
82736 }
82737
82738
82739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82740   int jresult ;
82741   int result;
82742
82743   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82744   jresult = (int)result;
82745   return jresult;
82746 }
82747
82748
82749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82750   int jresult ;
82751   int result;
82752
82753   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82754   jresult = (int)result;
82755   return jresult;
82756 }
82757
82758
82759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82760   int jresult ;
82761   int result;
82762
82763   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82764   jresult = (int)result;
82765   return jresult;
82766 }
82767
82768
82769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82770   int jresult ;
82771   int result;
82772
82773   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82774   jresult = (int)result;
82775   return jresult;
82776 }
82777
82778
82779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82780   int jresult ;
82781   int result;
82782
82783   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82784   jresult = (int)result;
82785   return jresult;
82786 }
82787
82788
82789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82790   int jresult ;
82791   int result;
82792
82793   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82794   jresult = (int)result;
82795   return jresult;
82796 }
82797
82798
82799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82800   int jresult ;
82801   int result;
82802
82803   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82804   jresult = (int)result;
82805   return jresult;
82806 }
82807
82808
82809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82810   int jresult ;
82811   int result;
82812
82813   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82814   jresult = (int)result;
82815   return jresult;
82816 }
82817
82818
82819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82820   int jresult ;
82821   int result;
82822
82823   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82824   jresult = (int)result;
82825   return jresult;
82826 }
82827
82828
82829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82830   int jresult ;
82831   int result;
82832
82833   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82834   jresult = (int)result;
82835   return jresult;
82836 }
82837
82838
82839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82840   int jresult ;
82841   int result;
82842
82843   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82844   jresult = (int)result;
82845   return jresult;
82846 }
82847
82848
82849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82850   int jresult ;
82851   int result;
82852
82853   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82854   jresult = (int)result;
82855   return jresult;
82856 }
82857
82858
82859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82860   int jresult ;
82861   int result;
82862
82863   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82864   jresult = (int)result;
82865   return jresult;
82866 }
82867
82868
82869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82870   int jresult ;
82871   int result;
82872
82873   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82874   jresult = (int)result;
82875   return jresult;
82876 }
82877
82878
82879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82880   void * jresult ;
82881   Dali::Toolkit::Popup::Property *result = 0 ;
82882
82883   {
82884     try {
82885       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82886     } catch (std::out_of_range& e) {
82887       {
82888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82889       };
82890     } catch (std::exception& e) {
82891       {
82892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82893       };
82894     } catch (...) {
82895       {
82896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82897       };
82898     }
82899   }
82900   jresult = (void *)result;
82901   return jresult;
82902 }
82903
82904
82905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82906   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82907
82908   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82909   {
82910     try {
82911       delete arg1;
82912     } catch (std::out_of_range& e) {
82913       {
82914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82915       };
82916     } catch (std::exception& e) {
82917       {
82918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82919       };
82920     } catch (...) {
82921       {
82922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82923       };
82924     }
82925   }
82926 }
82927
82928
82929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82930   void * jresult ;
82931   Dali::Toolkit::Popup *result = 0 ;
82932
82933   {
82934     try {
82935       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82936     } catch (std::out_of_range& e) {
82937       {
82938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82939       };
82940     } catch (std::exception& e) {
82941       {
82942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82947       };
82948     }
82949   }
82950   jresult = (void *)result;
82951   return jresult;
82952 }
82953
82954
82955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82956   void * jresult ;
82957   Dali::Toolkit::Popup result;
82958
82959   {
82960     try {
82961       result = Dali::Toolkit::Popup::New();
82962     } catch (std::out_of_range& e) {
82963       {
82964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82965       };
82966     } catch (std::exception& e) {
82967       {
82968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82969       };
82970     } catch (...) {
82971       {
82972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82973       };
82974     }
82975   }
82976   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82977   return jresult;
82978 }
82979
82980
82981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82982   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82983
82984   arg1 = (Dali::Toolkit::Popup *)jarg1;
82985   {
82986     try {
82987       delete arg1;
82988     } catch (std::out_of_range& e) {
82989       {
82990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82991       };
82992     } catch (std::exception& e) {
82993       {
82994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82995       };
82996     } catch (...) {
82997       {
82998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82999       };
83000     }
83001   }
83002 }
83003
83004
83005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83006   void * jresult ;
83007   Dali::Toolkit::Popup *arg1 = 0 ;
83008   Dali::Toolkit::Popup *result = 0 ;
83009
83010   arg1 = (Dali::Toolkit::Popup *)jarg1;
83011   if (!arg1) {
83012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83013     return 0;
83014   }
83015   {
83016     try {
83017       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83018     } catch (std::out_of_range& e) {
83019       {
83020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83021       };
83022     } catch (std::exception& e) {
83023       {
83024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83025       };
83026     } catch (...) {
83027       {
83028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83029       };
83030     }
83031   }
83032   jresult = (void *)result;
83033   return jresult;
83034 }
83035
83036
83037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83038   void * jresult ;
83039   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83040   Dali::Toolkit::Popup *arg2 = 0 ;
83041   Dali::Toolkit::Popup *result = 0 ;
83042
83043   arg1 = (Dali::Toolkit::Popup *)jarg1;
83044   arg2 = (Dali::Toolkit::Popup *)jarg2;
83045   if (!arg2) {
83046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83047     return 0;
83048   }
83049   {
83050     try {
83051       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83052     } catch (std::out_of_range& e) {
83053       {
83054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83055       };
83056     } catch (std::exception& e) {
83057       {
83058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83059       };
83060     } catch (...) {
83061       {
83062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83063       };
83064     }
83065   }
83066   jresult = (void *)result;
83067   return jresult;
83068 }
83069
83070
83071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83072   void * jresult ;
83073   Dali::BaseHandle arg1 ;
83074   Dali::BaseHandle *argp1 ;
83075   Dali::Toolkit::Popup result;
83076
83077   argp1 = (Dali::BaseHandle *)jarg1;
83078   if (!argp1) {
83079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83080     return 0;
83081   }
83082   arg1 = *argp1;
83083   {
83084     try {
83085       result = Dali::Toolkit::Popup::DownCast(arg1);
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (...) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83097       };
83098     }
83099   }
83100   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83101   return jresult;
83102 }
83103
83104
83105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83106   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83107   Dali::Actor arg2 ;
83108   Dali::Actor *argp2 ;
83109
83110   arg1 = (Dali::Toolkit::Popup *)jarg1;
83111   argp2 = (Dali::Actor *)jarg2;
83112   if (!argp2) {
83113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83114     return ;
83115   }
83116   arg2 = *argp2;
83117   {
83118     try {
83119       (arg1)->SetTitle(arg2);
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83127       };
83128     } catch (...) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83131       };
83132     }
83133   }
83134 }
83135
83136
83137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83138   void * jresult ;
83139   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83140   Dali::Actor result;
83141
83142   arg1 = (Dali::Toolkit::Popup *)jarg1;
83143   {
83144     try {
83145       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83146     } catch (std::out_of_range& e) {
83147       {
83148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83149       };
83150     } catch (std::exception& e) {
83151       {
83152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83153       };
83154     } catch (...) {
83155       {
83156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83157       };
83158     }
83159   }
83160   jresult = new Dali::Actor((const Dali::Actor &)result);
83161   return jresult;
83162 }
83163
83164
83165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83166   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83167   Dali::Actor arg2 ;
83168   Dali::Actor *argp2 ;
83169
83170   arg1 = (Dali::Toolkit::Popup *)jarg1;
83171   argp2 = (Dali::Actor *)jarg2;
83172   if (!argp2) {
83173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83174     return ;
83175   }
83176   arg2 = *argp2;
83177   {
83178     try {
83179       (arg1)->SetContent(arg2);
83180     } catch (std::out_of_range& e) {
83181       {
83182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83183       };
83184     } catch (std::exception& e) {
83185       {
83186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83187       };
83188     } catch (...) {
83189       {
83190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83191       };
83192     }
83193   }
83194 }
83195
83196
83197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83198   void * jresult ;
83199   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83200   Dali::Actor result;
83201
83202   arg1 = (Dali::Toolkit::Popup *)jarg1;
83203   {
83204     try {
83205       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83206     } catch (std::out_of_range& e) {
83207       {
83208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83209       };
83210     } catch (std::exception& e) {
83211       {
83212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83213       };
83214     } catch (...) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83217       };
83218     }
83219   }
83220   jresult = new Dali::Actor((const Dali::Actor &)result);
83221   return jresult;
83222 }
83223
83224
83225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83226   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83227   Dali::Actor arg2 ;
83228   Dali::Actor *argp2 ;
83229
83230   arg1 = (Dali::Toolkit::Popup *)jarg1;
83231   argp2 = (Dali::Actor *)jarg2;
83232   if (!argp2) {
83233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83234     return ;
83235   }
83236   arg2 = *argp2;
83237   {
83238     try {
83239       (arg1)->SetFooter(arg2);
83240     } catch (std::out_of_range& e) {
83241       {
83242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83243       };
83244     } catch (std::exception& e) {
83245       {
83246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83247       };
83248     } catch (...) {
83249       {
83250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83251       };
83252     }
83253   }
83254 }
83255
83256
83257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83258   void * jresult ;
83259   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83260   Dali::Actor result;
83261
83262   arg1 = (Dali::Toolkit::Popup *)jarg1;
83263   {
83264     try {
83265       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83266     } catch (std::out_of_range& e) {
83267       {
83268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83269       };
83270     } catch (std::exception& e) {
83271       {
83272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83273       };
83274     } catch (...) {
83275       {
83276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83277       };
83278     }
83279   }
83280   jresult = new Dali::Actor((const Dali::Actor &)result);
83281   return jresult;
83282 }
83283
83284
83285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83286   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83287   Dali::Toolkit::Popup::DisplayState arg2 ;
83288
83289   arg1 = (Dali::Toolkit::Popup *)jarg1;
83290   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83291   {
83292     try {
83293       (arg1)->SetDisplayState(arg2);
83294     } catch (std::out_of_range& e) {
83295       {
83296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83297       };
83298     } catch (std::exception& e) {
83299       {
83300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83301       };
83302     } catch (...) {
83303       {
83304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83305       };
83306     }
83307   }
83308 }
83309
83310
83311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83312   int jresult ;
83313   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83314   Dali::Toolkit::Popup::DisplayState result;
83315
83316   arg1 = (Dali::Toolkit::Popup *)jarg1;
83317   {
83318     try {
83319       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83320     } catch (std::out_of_range& e) {
83321       {
83322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83323       };
83324     } catch (std::exception& e) {
83325       {
83326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83327       };
83328     } catch (...) {
83329       {
83330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83331       };
83332     }
83333   }
83334   jresult = (int)result;
83335   return jresult;
83336 }
83337
83338
83339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83340   void * jresult ;
83341   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83342   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83343
83344   arg1 = (Dali::Toolkit::Popup *)jarg1;
83345   {
83346     try {
83347       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83348     } catch (std::out_of_range& e) {
83349       {
83350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83351       };
83352     } catch (std::exception& e) {
83353       {
83354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83355       };
83356     } catch (...) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83359       };
83360     }
83361   }
83362   jresult = (void *)result;
83363   return jresult;
83364 }
83365
83366
83367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83368   void * jresult ;
83369   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83370   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83371
83372   arg1 = (Dali::Toolkit::Popup *)jarg1;
83373   {
83374     try {
83375       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83376     } catch (std::out_of_range& e) {
83377       {
83378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83379       };
83380     } catch (std::exception& e) {
83381       {
83382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83383       };
83384     } catch (...) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83387       };
83388     }
83389   }
83390   jresult = (void *)result;
83391   return jresult;
83392 }
83393
83394
83395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83396   void * jresult ;
83397   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83398   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83399
83400   arg1 = (Dali::Toolkit::Popup *)jarg1;
83401   {
83402     try {
83403       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83404     } catch (std::out_of_range& e) {
83405       {
83406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83407       };
83408     } catch (std::exception& e) {
83409       {
83410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83411       };
83412     } catch (...) {
83413       {
83414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83415       };
83416     }
83417   }
83418   jresult = (void *)result;
83419   return jresult;
83420 }
83421
83422
83423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83424   void * jresult ;
83425   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83426   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83427
83428   arg1 = (Dali::Toolkit::Popup *)jarg1;
83429   {
83430     try {
83431       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83432     } catch (std::out_of_range& e) {
83433       {
83434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83435       };
83436     } catch (std::exception& e) {
83437       {
83438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83439       };
83440     } catch (...) {
83441       {
83442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83443       };
83444     }
83445   }
83446   jresult = (void *)result;
83447   return jresult;
83448 }
83449
83450
83451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83452   void * jresult ;
83453   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83454   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83455
83456   arg1 = (Dali::Toolkit::Popup *)jarg1;
83457   {
83458     try {
83459       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83460     } catch (std::out_of_range& e) {
83461       {
83462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83463       };
83464     } catch (std::exception& e) {
83465       {
83466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83467       };
83468     } catch (...) {
83469       {
83470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83471       };
83472     }
83473   }
83474   jresult = (void *)result;
83475   return jresult;
83476 }
83477
83478
83479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83480   int jresult ;
83481   int result;
83482
83483   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83484   jresult = (int)result;
83485   return jresult;
83486 }
83487
83488
83489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83490   int jresult ;
83491   int result;
83492
83493   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83494   jresult = (int)result;
83495   return jresult;
83496 }
83497
83498
83499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83500   int jresult ;
83501   int result;
83502
83503   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83504   jresult = (int)result;
83505   return jresult;
83506 }
83507
83508
83509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83510   int jresult ;
83511   int result;
83512
83513   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83514   jresult = (int)result;
83515   return jresult;
83516 }
83517
83518
83519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83520   int jresult ;
83521   int result;
83522
83523   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83524   jresult = (int)result;
83525   return jresult;
83526 }
83527
83528
83529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83530   int jresult ;
83531   int result;
83532
83533   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83534   jresult = (int)result;
83535   return jresult;
83536 }
83537
83538
83539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83540   int jresult ;
83541   int result;
83542
83543   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83544   jresult = (int)result;
83545   return jresult;
83546 }
83547
83548
83549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83550   int jresult ;
83551   int result;
83552
83553   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83554   jresult = (int)result;
83555   return jresult;
83556 }
83557
83558
83559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83560   int jresult ;
83561   int result;
83562
83563   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83564   jresult = (int)result;
83565   return jresult;
83566 }
83567
83568
83569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83570   void * jresult ;
83571   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83572
83573   {
83574     try {
83575       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83576     } catch (std::out_of_range& e) {
83577       {
83578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83579       };
83580     } catch (std::exception& e) {
83581       {
83582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83583       };
83584     } catch (...) {
83585       {
83586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83587       };
83588     }
83589   }
83590   jresult = (void *)result;
83591   return jresult;
83592 }
83593
83594
83595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83596   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83597
83598   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83599   {
83600     try {
83601       delete arg1;
83602     } catch (std::out_of_range& e) {
83603       {
83604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83605       };
83606     } catch (std::exception& e) {
83607       {
83608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83609       };
83610     } catch (...) {
83611       {
83612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83613       };
83614     }
83615   }
83616 }
83617
83618
83619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83620   void * jresult ;
83621   Dali::Toolkit::ProgressBar result;
83622
83623   {
83624     try {
83625       result = Dali::Toolkit::ProgressBar::New();
83626     } catch (std::out_of_range& e) {
83627       {
83628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83629       };
83630     } catch (std::exception& e) {
83631       {
83632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83633       };
83634     } catch (...) {
83635       {
83636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83637       };
83638     }
83639   }
83640   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83641   return jresult;
83642 }
83643
83644
83645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83646   void * jresult ;
83647   Dali::Toolkit::ProgressBar *result = 0 ;
83648
83649   {
83650     try {
83651       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83652     } catch (std::out_of_range& e) {
83653       {
83654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83655       };
83656     } catch (std::exception& e) {
83657       {
83658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83659       };
83660     } catch (...) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83663       };
83664     }
83665   }
83666   jresult = (void *)result;
83667   return jresult;
83668 }
83669
83670
83671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83672   void * jresult ;
83673   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83674   Dali::Toolkit::ProgressBar *result = 0 ;
83675
83676   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83677   if (!arg1) {
83678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83679     return 0;
83680   }
83681   {
83682     try {
83683       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83684     } catch (std::out_of_range& e) {
83685       {
83686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83687       };
83688     } catch (std::exception& e) {
83689       {
83690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83691       };
83692     } catch (...) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83695       };
83696     }
83697   }
83698   jresult = (void *)result;
83699   return jresult;
83700 }
83701
83702
83703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83704   void * jresult ;
83705   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83706   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83707   Dali::Toolkit::ProgressBar *result = 0 ;
83708
83709   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83710   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83711   if (!arg2) {
83712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83713     return 0;
83714   }
83715   {
83716     try {
83717       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (...) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83729       };
83730     }
83731   }
83732   jresult = (void *)result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83738   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83739
83740   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83741   {
83742     try {
83743       delete arg1;
83744     } catch (std::out_of_range& e) {
83745       {
83746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83747       };
83748     } catch (std::exception& e) {
83749       {
83750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83751       };
83752     } catch (...) {
83753       {
83754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83755       };
83756     }
83757   }
83758 }
83759
83760
83761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83762   void * jresult ;
83763   Dali::BaseHandle arg1 ;
83764   Dali::BaseHandle *argp1 ;
83765   Dali::Toolkit::ProgressBar result;
83766
83767   argp1 = (Dali::BaseHandle *)jarg1;
83768   if (!argp1) {
83769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83770     return 0;
83771   }
83772   arg1 = *argp1;
83773   {
83774     try {
83775       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83776     } catch (std::out_of_range& e) {
83777       {
83778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83779       };
83780     } catch (std::exception& e) {
83781       {
83782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83783       };
83784     } catch (...) {
83785       {
83786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83787       };
83788     }
83789   }
83790   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83791   return jresult;
83792 }
83793
83794
83795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83796   void * jresult ;
83797   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83798   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83799
83800   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83801   {
83802     try {
83803       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83804     } catch (std::out_of_range& e) {
83805       {
83806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83807       };
83808     } catch (std::exception& e) {
83809       {
83810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83811       };
83812     } catch (...) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83815       };
83816     }
83817   }
83818   jresult = (void *)result;
83819   return jresult;
83820 }
83821
83822
83823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83824   void * jresult ;
83825   Dali::Toolkit::GaussianBlurView *result = 0 ;
83826
83827   {
83828     try {
83829       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83830     } catch (std::out_of_range& e) {
83831       {
83832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83833       };
83834     } catch (std::exception& e) {
83835       {
83836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83837       };
83838     } catch (...) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83841       };
83842     }
83843   }
83844   jresult = (void *)result;
83845   return jresult;
83846 }
83847
83848
83849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83850   void * jresult ;
83851   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83852   Dali::Toolkit::GaussianBlurView *result = 0 ;
83853
83854   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83855   if (!arg1) {
83856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83857     return 0;
83858   }
83859   {
83860     try {
83861       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83862     } catch (std::out_of_range& e) {
83863       {
83864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83865       };
83866     } catch (std::exception& e) {
83867       {
83868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83869       };
83870     } catch (...) {
83871       {
83872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83873       };
83874     }
83875   }
83876   jresult = (void *)result;
83877   return jresult;
83878 }
83879
83880
83881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83882   void * jresult ;
83883   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83884   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83885   Dali::Toolkit::GaussianBlurView *result = 0 ;
83886
83887   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83888   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83889   if (!arg2) {
83890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83891     return 0;
83892   }
83893   {
83894     try {
83895       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83896     } catch (std::out_of_range& e) {
83897       {
83898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83899       };
83900     } catch (std::exception& e) {
83901       {
83902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83903       };
83904     } catch (...) {
83905       {
83906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83907       };
83908     }
83909   }
83910   jresult = (void *)result;
83911   return jresult;
83912 }
83913
83914
83915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83916   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83917
83918   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83919   {
83920     try {
83921       delete arg1;
83922     } catch (std::out_of_range& e) {
83923       {
83924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83925       };
83926     } catch (std::exception& e) {
83927       {
83928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83929       };
83930     } catch (...) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83933       };
83934     }
83935   }
83936 }
83937
83938
83939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83940   void * jresult ;
83941   Dali::BaseHandle arg1 ;
83942   Dali::BaseHandle *argp1 ;
83943   Dali::Toolkit::GaussianBlurView result;
83944
83945   argp1 = (Dali::BaseHandle *)jarg1;
83946   if (!argp1) {
83947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83948     return 0;
83949   }
83950   arg1 = *argp1;
83951   {
83952     try {
83953       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83954     } catch (std::out_of_range& e) {
83955       {
83956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83957       };
83958     } catch (std::exception& e) {
83959       {
83960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83961       };
83962     } catch (...) {
83963       {
83964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83965       };
83966     }
83967   }
83968   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83969   return jresult;
83970 }
83971
83972
83973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83974   void * jresult ;
83975   Dali::Toolkit::GaussianBlurView result;
83976
83977   {
83978     try {
83979       result = Dali::Toolkit::GaussianBlurView::New();
83980     } catch (std::out_of_range& e) {
83981       {
83982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83983       };
83984     } catch (std::exception& e) {
83985       {
83986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83987       };
83988     } catch (...) {
83989       {
83990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83991       };
83992     }
83993   }
83994   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83995   return jresult;
83996 }
83997
83998
83999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84000   void * jresult ;
84001   unsigned int arg1 ;
84002   float arg2 ;
84003   Dali::Pixel::Format arg3 ;
84004   float arg4 ;
84005   float arg5 ;
84006   bool arg6 ;
84007   Dali::Toolkit::GaussianBlurView result;
84008
84009   arg1 = (unsigned int)jarg1;
84010   arg2 = (float)jarg2;
84011   arg3 = (Dali::Pixel::Format)jarg3;
84012   arg4 = (float)jarg4;
84013   arg5 = (float)jarg5;
84014   arg6 = jarg6 ? true : false;
84015   {
84016     try {
84017       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84018     } catch (std::out_of_range& e) {
84019       {
84020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (std::exception& e) {
84023       {
84024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84025       };
84026     } catch (...) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84029       };
84030     }
84031   }
84032   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84033   return jresult;
84034 }
84035
84036
84037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84038   void * jresult ;
84039   unsigned int arg1 ;
84040   float arg2 ;
84041   Dali::Pixel::Format arg3 ;
84042   float arg4 ;
84043   float arg5 ;
84044   Dali::Toolkit::GaussianBlurView result;
84045
84046   arg1 = (unsigned int)jarg1;
84047   arg2 = (float)jarg2;
84048   arg3 = (Dali::Pixel::Format)jarg3;
84049   arg4 = (float)jarg4;
84050   arg5 = (float)jarg5;
84051   {
84052     try {
84053       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84054     } catch (std::out_of_range& e) {
84055       {
84056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84057       };
84058     } catch (std::exception& e) {
84059       {
84060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (...) {
84063       {
84064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84065       };
84066     }
84067   }
84068   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84069   return jresult;
84070 }
84071
84072
84073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84074   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84075   Dali::Actor arg2 ;
84076   Dali::Actor *argp2 ;
84077
84078   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84079   argp2 = (Dali::Actor *)jarg2;
84080   if (!argp2) {
84081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84082     return ;
84083   }
84084   arg2 = *argp2;
84085   {
84086     try {
84087       (arg1)->Add(arg2);
84088     } catch (std::out_of_range& e) {
84089       {
84090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84091       };
84092     } catch (std::exception& e) {
84093       {
84094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84095       };
84096     } catch (...) {
84097       {
84098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84099       };
84100     }
84101   }
84102 }
84103
84104
84105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84106   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84107   Dali::Actor arg2 ;
84108   Dali::Actor *argp2 ;
84109
84110   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84111   argp2 = (Dali::Actor *)jarg2;
84112   if (!argp2) {
84113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84114     return ;
84115   }
84116   arg2 = *argp2;
84117   {
84118     try {
84119       (arg1)->Remove(arg2);
84120     } catch (std::out_of_range& e) {
84121       {
84122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84123       };
84124     } catch (std::exception& e) {
84125       {
84126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84127       };
84128     } catch (...) {
84129       {
84130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84131       };
84132     }
84133   }
84134 }
84135
84136
84137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84139
84140   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84141   {
84142     try {
84143       (arg1)->Activate();
84144     } catch (std::out_of_range& e) {
84145       {
84146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84147       };
84148     } catch (std::exception& e) {
84149       {
84150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84151       };
84152     } catch (...) {
84153       {
84154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84155       };
84156     }
84157   }
84158 }
84159
84160
84161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84162   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84163
84164   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84165   {
84166     try {
84167       (arg1)->ActivateOnce();
84168     } catch (std::out_of_range& e) {
84169       {
84170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84171       };
84172     } catch (std::exception& e) {
84173       {
84174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84175       };
84176     } catch (...) {
84177       {
84178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84179       };
84180     }
84181   }
84182 }
84183
84184
84185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84186   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84187
84188   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84189   {
84190     try {
84191       (arg1)->Deactivate();
84192     } catch (std::out_of_range& e) {
84193       {
84194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84195       };
84196     } catch (std::exception& e) {
84197       {
84198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84199       };
84200     } catch (...) {
84201       {
84202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84203       };
84204     }
84205   }
84206 }
84207
84208
84209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84210   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84211   Dali::Image arg2 ;
84212   Dali::FrameBufferImage arg3 ;
84213   Dali::Image *argp2 ;
84214   Dali::FrameBufferImage *argp3 ;
84215
84216   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84217   argp2 = (Dali::Image *)jarg2;
84218   if (!argp2) {
84219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84220     return ;
84221   }
84222   arg2 = *argp2;
84223   argp3 = (Dali::FrameBufferImage *)jarg3;
84224   if (!argp3) {
84225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84226     return ;
84227   }
84228   arg3 = *argp3;
84229   {
84230     try {
84231       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84232     } catch (std::out_of_range& e) {
84233       {
84234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84235       };
84236     } catch (std::exception& e) {
84237       {
84238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84239       };
84240     } catch (...) {
84241       {
84242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84243       };
84244     }
84245   }
84246 }
84247
84248
84249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84250   int jresult ;
84251   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84252   Dali::Property::Index result;
84253
84254   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84255   {
84256     try {
84257       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84258     } catch (std::out_of_range& e) {
84259       {
84260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84261       };
84262     } catch (std::exception& e) {
84263       {
84264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84265       };
84266     } catch (...) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84269       };
84270     }
84271   }
84272   jresult = result;
84273   return jresult;
84274 }
84275
84276
84277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84278   void * jresult ;
84279   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84280   Dali::FrameBufferImage result;
84281
84282   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84283   {
84284     try {
84285       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84286     } catch (std::out_of_range& e) {
84287       {
84288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84289       };
84290     } catch (std::exception& e) {
84291       {
84292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84293       };
84294     } catch (...) {
84295       {
84296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84297       };
84298     }
84299   }
84300   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84301   return jresult;
84302 }
84303
84304
84305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84306   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84307   Dali::Vector4 *arg2 = 0 ;
84308
84309   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84310   arg2 = (Dali::Vector4 *)jarg2;
84311   if (!arg2) {
84312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84313     return ;
84314   }
84315   {
84316     try {
84317       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84318     } catch (std::out_of_range& e) {
84319       {
84320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84321       };
84322     } catch (std::exception& e) {
84323       {
84324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84325       };
84326     } catch (...) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84329       };
84330     }
84331   }
84332 }
84333
84334
84335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84336   void * jresult ;
84337   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84338   Dali::Vector4 result;
84339
84340   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84341   {
84342     try {
84343       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84344     } catch (std::out_of_range& e) {
84345       {
84346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84347       };
84348     } catch (std::exception& e) {
84349       {
84350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84351       };
84352     } catch (...) {
84353       {
84354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84355       };
84356     }
84357   }
84358   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84359   return jresult;
84360 }
84361
84362
84363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84364   void * jresult ;
84365   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84366   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84367
84368   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84369   {
84370     try {
84371       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84372     } catch (std::out_of_range& e) {
84373       {
84374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84375       };
84376     } catch (std::exception& e) {
84377       {
84378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84379       };
84380     } catch (...) {
84381       {
84382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84383       };
84384     }
84385   }
84386   jresult = (void *)result;
84387   return jresult;
84388 }
84389
84390
84391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84392   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84393
84394   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84395   {
84396     try {
84397       delete arg1;
84398     } catch (std::out_of_range& e) {
84399       {
84400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84401       };
84402     } catch (std::exception& e) {
84403       {
84404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84405       };
84406     } catch (...) {
84407       {
84408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84409       };
84410     }
84411   }
84412 }
84413
84414
84415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84416   unsigned int jresult ;
84417   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84418   unsigned int result;
84419
84420   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84421   {
84422     try {
84423       result = (unsigned int)(arg1)->GetNumberOfPages();
84424     } catch (std::out_of_range& e) {
84425       {
84426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84427       };
84428     } catch (std::exception& e) {
84429       {
84430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84431       };
84432     } catch (...) {
84433       {
84434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84435       };
84436     }
84437   }
84438   jresult = result;
84439   return jresult;
84440 }
84441
84442
84443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84444   void * jresult ;
84445   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84446   unsigned int arg2 ;
84447   Dali::Texture result;
84448
84449   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84450   arg2 = (unsigned int)jarg2;
84451   {
84452     try {
84453       result = (arg1)->NewPage(arg2);
84454     } catch (std::out_of_range& e) {
84455       {
84456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84457       };
84458     } catch (std::exception& e) {
84459       {
84460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (...) {
84463       {
84464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84465       };
84466     }
84467   }
84468   jresult = new Dali::Texture((const Dali::Texture &)result);
84469   return jresult;
84470 }
84471
84472
84473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84474   int jresult ;
84475   int result;
84476
84477   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84478   jresult = (int)result;
84479   return jresult;
84480 }
84481
84482
84483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84484   int jresult ;
84485   int result;
84486
84487   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84488   jresult = (int)result;
84489   return jresult;
84490 }
84491
84492
84493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84494   int jresult ;
84495   int result;
84496
84497   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84498   jresult = (int)result;
84499   return jresult;
84500 }
84501
84502
84503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84504   void * jresult ;
84505   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84506
84507   {
84508     try {
84509       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84510     } catch (std::out_of_range& e) {
84511       {
84512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84513       };
84514     } catch (std::exception& e) {
84515       {
84516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (...) {
84519       {
84520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84521       };
84522     }
84523   }
84524   jresult = (void *)result;
84525   return jresult;
84526 }
84527
84528
84529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84530   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84531
84532   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84533   {
84534     try {
84535       delete arg1;
84536     } catch (std::out_of_range& e) {
84537       {
84538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84539       };
84540     } catch (std::exception& e) {
84541       {
84542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84543       };
84544     } catch (...) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84547       };
84548     }
84549   }
84550 }
84551
84552
84553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84554   void * jresult ;
84555   Dali::Toolkit::PageTurnView *result = 0 ;
84556
84557   {
84558     try {
84559       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84560     } catch (std::out_of_range& e) {
84561       {
84562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84563       };
84564     } catch (std::exception& e) {
84565       {
84566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84567       };
84568     } catch (...) {
84569       {
84570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84571       };
84572     }
84573   }
84574   jresult = (void *)result;
84575   return jresult;
84576 }
84577
84578
84579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84580   void * jresult ;
84581   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84582   Dali::Toolkit::PageTurnView *result = 0 ;
84583
84584   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84585   if (!arg1) {
84586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84587     return 0;
84588   }
84589   {
84590     try {
84591       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84592     } catch (std::out_of_range& e) {
84593       {
84594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84595       };
84596     } catch (std::exception& e) {
84597       {
84598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84599       };
84600     } catch (...) {
84601       {
84602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84603       };
84604     }
84605   }
84606   jresult = (void *)result;
84607   return jresult;
84608 }
84609
84610
84611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84612   void * jresult ;
84613   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84614   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84615   Dali::Toolkit::PageTurnView *result = 0 ;
84616
84617   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84618   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84619   if (!arg2) {
84620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84621     return 0;
84622   }
84623   {
84624     try {
84625       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84626     } catch (std::out_of_range& e) {
84627       {
84628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84629       };
84630     } catch (std::exception& e) {
84631       {
84632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (...) {
84635       {
84636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84637       };
84638     }
84639   }
84640   jresult = (void *)result;
84641   return jresult;
84642 }
84643
84644
84645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84646   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84647
84648   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84649   {
84650     try {
84651       delete arg1;
84652     } catch (std::out_of_range& e) {
84653       {
84654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84655       };
84656     } catch (std::exception& e) {
84657       {
84658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84659       };
84660     } catch (...) {
84661       {
84662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84663       };
84664     }
84665   }
84666 }
84667
84668
84669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84670   void * jresult ;
84671   Dali::BaseHandle arg1 ;
84672   Dali::BaseHandle *argp1 ;
84673   Dali::Toolkit::PageTurnView result;
84674
84675   argp1 = (Dali::BaseHandle *)jarg1;
84676   if (!argp1) {
84677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84678     return 0;
84679   }
84680   arg1 = *argp1;
84681   {
84682     try {
84683       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84684     } catch (std::out_of_range& e) {
84685       {
84686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84687       };
84688     } catch (std::exception& e) {
84689       {
84690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84691       };
84692     } catch (...) {
84693       {
84694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84695       };
84696     }
84697   }
84698   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84699   return jresult;
84700 }
84701
84702
84703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84704   void * jresult ;
84705   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84706   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84707
84708   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84709   {
84710     try {
84711       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84712     } catch (std::out_of_range& e) {
84713       {
84714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84715       };
84716     } catch (std::exception& e) {
84717       {
84718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84719       };
84720     } catch (...) {
84721       {
84722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84723       };
84724     }
84725   }
84726   jresult = (void *)result;
84727   return jresult;
84728 }
84729
84730
84731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84732   void * jresult ;
84733   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84734   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84735
84736   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84737   {
84738     try {
84739       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84740     } catch (std::out_of_range& e) {
84741       {
84742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84743       };
84744     } catch (std::exception& e) {
84745       {
84746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84747       };
84748     } catch (...) {
84749       {
84750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84751       };
84752     }
84753   }
84754   jresult = (void *)result;
84755   return jresult;
84756 }
84757
84758
84759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84760   void * jresult ;
84761   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84762   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84763
84764   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84765   {
84766     try {
84767       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84768     } catch (std::out_of_range& e) {
84769       {
84770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84771       };
84772     } catch (std::exception& e) {
84773       {
84774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84775       };
84776     } catch (...) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84779       };
84780     }
84781   }
84782   jresult = (void *)result;
84783   return jresult;
84784 }
84785
84786
84787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84788   void * jresult ;
84789   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84790   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84791
84792   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84793   {
84794     try {
84795       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84796     } catch (std::out_of_range& e) {
84797       {
84798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84799       };
84800     } catch (std::exception& e) {
84801       {
84802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84803       };
84804     } catch (...) {
84805       {
84806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84807       };
84808     }
84809   }
84810   jresult = (void *)result;
84811   return jresult;
84812 }
84813
84814
84815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84816   void * jresult ;
84817   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84818
84819   {
84820     try {
84821       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84822     } catch (std::out_of_range& e) {
84823       {
84824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84825       };
84826     } catch (std::exception& e) {
84827       {
84828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84829       };
84830     } catch (...) {
84831       {
84832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84833       };
84834     }
84835   }
84836   jresult = (void *)result;
84837   return jresult;
84838 }
84839
84840
84841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84842   void * jresult ;
84843   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84844   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84845
84846   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84847   if (!arg1) {
84848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84849     return 0;
84850   }
84851   {
84852     try {
84853       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84854     } catch (std::out_of_range& e) {
84855       {
84856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84857       };
84858     } catch (std::exception& e) {
84859       {
84860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84861       };
84862     } catch (...) {
84863       {
84864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84865       };
84866     }
84867   }
84868   jresult = (void *)result;
84869   return jresult;
84870 }
84871
84872
84873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84874   void * jresult ;
84875   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84876   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84877   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84878
84879   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84880   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84881   if (!arg2) {
84882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84883     return 0;
84884   }
84885   {
84886     try {
84887       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84888     } catch (std::out_of_range& e) {
84889       {
84890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84891       };
84892     } catch (std::exception& e) {
84893       {
84894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84895       };
84896     } catch (...) {
84897       {
84898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84899       };
84900     }
84901   }
84902   jresult = (void *)result;
84903   return jresult;
84904 }
84905
84906
84907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84908   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84909
84910   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84911   {
84912     try {
84913       delete arg1;
84914     } catch (std::out_of_range& e) {
84915       {
84916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84917       };
84918     } catch (std::exception& e) {
84919       {
84920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84921       };
84922     } catch (...) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84925       };
84926     }
84927   }
84928 }
84929
84930
84931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84932   void * jresult ;
84933   Dali::Toolkit::PageFactory *arg1 = 0 ;
84934   Dali::Vector2 *arg2 = 0 ;
84935   Dali::Toolkit::PageTurnLandscapeView result;
84936
84937   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84938   if (!arg1) {
84939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84940     return 0;
84941   }
84942   arg2 = (Dali::Vector2 *)jarg2;
84943   if (!arg2) {
84944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84945     return 0;
84946   }
84947   {
84948     try {
84949       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84950     } catch (std::out_of_range& e) {
84951       {
84952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84953       };
84954     } catch (std::exception& e) {
84955       {
84956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84957       };
84958     } catch (...) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84961       };
84962     }
84963   }
84964   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84965   return jresult;
84966 }
84967
84968
84969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84970   void * jresult ;
84971   Dali::BaseHandle arg1 ;
84972   Dali::BaseHandle *argp1 ;
84973   Dali::Toolkit::PageTurnLandscapeView result;
84974
84975   argp1 = (Dali::BaseHandle *)jarg1;
84976   if (!argp1) {
84977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84978     return 0;
84979   }
84980   arg1 = *argp1;
84981   {
84982     try {
84983       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84984     } catch (std::out_of_range& e) {
84985       {
84986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84987       };
84988     } catch (std::exception& e) {
84989       {
84990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (...) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84995       };
84996     }
84997   }
84998   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84999   return jresult;
85000 }
85001
85002
85003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85004   void * jresult ;
85005   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85006
85007   {
85008     try {
85009       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85010     } catch (std::out_of_range& e) {
85011       {
85012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85013       };
85014     } catch (std::exception& e) {
85015       {
85016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85017       };
85018     } catch (...) {
85019       {
85020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85021       };
85022     }
85023   }
85024   jresult = (void *)result;
85025   return jresult;
85026 }
85027
85028
85029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85030   void * jresult ;
85031   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85032   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85033
85034   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85035   if (!arg1) {
85036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85037     return 0;
85038   }
85039   {
85040     try {
85041       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85042     } catch (std::out_of_range& e) {
85043       {
85044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85045       };
85046     } catch (std::exception& e) {
85047       {
85048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85049       };
85050     } catch (...) {
85051       {
85052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85053       };
85054     }
85055   }
85056   jresult = (void *)result;
85057   return jresult;
85058 }
85059
85060
85061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85062   void * jresult ;
85063   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85064   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85065   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85066
85067   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85068   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85069   if (!arg2) {
85070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85071     return 0;
85072   }
85073   {
85074     try {
85075       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85076     } catch (std::out_of_range& e) {
85077       {
85078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85079       };
85080     } catch (std::exception& e) {
85081       {
85082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (...) {
85085       {
85086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85087       };
85088     }
85089   }
85090   jresult = (void *)result;
85091   return jresult;
85092 }
85093
85094
85095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85096   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85097
85098   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85099   {
85100     try {
85101       delete arg1;
85102     } catch (std::out_of_range& e) {
85103       {
85104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85105       };
85106     } catch (std::exception& e) {
85107       {
85108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85109       };
85110     } catch (...) {
85111       {
85112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85113       };
85114     }
85115   }
85116 }
85117
85118
85119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85120   void * jresult ;
85121   Dali::Toolkit::PageFactory *arg1 = 0 ;
85122   Dali::Vector2 *arg2 = 0 ;
85123   Dali::Toolkit::PageTurnPortraitView result;
85124
85125   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85126   if (!arg1) {
85127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85128     return 0;
85129   }
85130   arg2 = (Dali::Vector2 *)jarg2;
85131   if (!arg2) {
85132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85133     return 0;
85134   }
85135   {
85136     try {
85137       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85138     } catch (std::out_of_range& e) {
85139       {
85140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85141       };
85142     } catch (std::exception& e) {
85143       {
85144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85145       };
85146     } catch (...) {
85147       {
85148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85149       };
85150     }
85151   }
85152   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85153   return jresult;
85154 }
85155
85156
85157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85158   void * jresult ;
85159   Dali::BaseHandle arg1 ;
85160   Dali::BaseHandle *argp1 ;
85161   Dali::Toolkit::PageTurnPortraitView result;
85162
85163   argp1 = (Dali::BaseHandle *)jarg1;
85164   if (!argp1) {
85165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85166     return 0;
85167   }
85168   arg1 = *argp1;
85169   {
85170     try {
85171       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85172     } catch (std::out_of_range& e) {
85173       {
85174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (std::exception& e) {
85177       {
85178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (...) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85183       };
85184     }
85185   }
85186   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85187   return jresult;
85188 }
85189
85190
85191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85192   int jresult ;
85193   int result;
85194
85195   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85196   jresult = (int)result;
85197   return jresult;
85198 }
85199
85200
85201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85202   int jresult ;
85203   int result;
85204
85205   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85206   jresult = (int)result;
85207   return jresult;
85208 }
85209
85210
85211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85212   int jresult ;
85213   int result;
85214
85215   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85216   jresult = (int)result;
85217   return jresult;
85218 }
85219
85220
85221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85222   void * jresult ;
85223   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85224
85225   {
85226     try {
85227       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85228     } catch (std::out_of_range& e) {
85229       {
85230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85231       };
85232     } catch (std::exception& e) {
85233       {
85234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85235       };
85236     } catch (...) {
85237       {
85238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85239       };
85240     }
85241   }
85242   jresult = (void *)result;
85243   return jresult;
85244 }
85245
85246
85247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85248   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85249
85250   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85251   {
85252     try {
85253       delete arg1;
85254     } catch (std::out_of_range& e) {
85255       {
85256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85257       };
85258     } catch (std::exception& e) {
85259       {
85260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85261       };
85262     } catch (...) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85265       };
85266     }
85267   }
85268 }
85269
85270
85271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85272   void * jresult ;
85273   Dali::Toolkit::ToggleButton *result = 0 ;
85274
85275   {
85276     try {
85277       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85278     } catch (std::out_of_range& e) {
85279       {
85280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85281       };
85282     } catch (std::exception& e) {
85283       {
85284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85285       };
85286     } catch (...) {
85287       {
85288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85289       };
85290     }
85291   }
85292   jresult = (void *)result;
85293   return jresult;
85294 }
85295
85296
85297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85298   void * jresult ;
85299   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85300   Dali::Toolkit::ToggleButton *result = 0 ;
85301
85302   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85303   if (!arg1) {
85304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85305     return 0;
85306   }
85307   {
85308     try {
85309       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (...) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85321       };
85322     }
85323   }
85324   jresult = (void *)result;
85325   return jresult;
85326 }
85327
85328
85329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85330   void * jresult ;
85331   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85332   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85333   Dali::Toolkit::ToggleButton *result = 0 ;
85334
85335   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85336   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85337   if (!arg2) {
85338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85339     return 0;
85340   }
85341   {
85342     try {
85343       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85344     } catch (std::out_of_range& e) {
85345       {
85346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85347       };
85348     } catch (std::exception& e) {
85349       {
85350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85351       };
85352     } catch (...) {
85353       {
85354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85355       };
85356     }
85357   }
85358   jresult = (void *)result;
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85364   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85365
85366   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85367   {
85368     try {
85369       delete arg1;
85370     } catch (std::out_of_range& e) {
85371       {
85372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85373       };
85374     } catch (std::exception& e) {
85375       {
85376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85377       };
85378     } catch (...) {
85379       {
85380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85381       };
85382     }
85383   }
85384 }
85385
85386
85387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85388   void * jresult ;
85389   Dali::Toolkit::ToggleButton result;
85390
85391   {
85392     try {
85393       result = Dali::Toolkit::ToggleButton::New();
85394     } catch (std::out_of_range& e) {
85395       {
85396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85397       };
85398     } catch (std::exception& e) {
85399       {
85400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85401       };
85402     } catch (...) {
85403       {
85404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85405       };
85406     }
85407   }
85408   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85409   return jresult;
85410 }
85411
85412
85413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85414   void * jresult ;
85415   Dali::BaseHandle arg1 ;
85416   Dali::BaseHandle *argp1 ;
85417   Dali::Toolkit::ToggleButton result;
85418
85419   argp1 = (Dali::BaseHandle *)jarg1;
85420   if (!argp1) {
85421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85422     return 0;
85423   }
85424   arg1 = *argp1;
85425   {
85426     try {
85427       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85428     } catch (std::out_of_range& e) {
85429       {
85430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (std::exception& e) {
85433       {
85434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85439       };
85440     }
85441   }
85442   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85443   return jresult;
85444 }
85445
85446
85447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85448   void * jresult ;
85449   Dali::Toolkit::Visual::Base *result = 0 ;
85450
85451   {
85452     try {
85453       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85454     } catch (std::out_of_range& e) {
85455       {
85456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (std::exception& e) {
85459       {
85460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85461       };
85462     } catch (...) {
85463       {
85464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85465       };
85466     }
85467   }
85468   jresult = (void *)result;
85469   return jresult;
85470 }
85471
85472
85473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85474   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85475
85476   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85477   {
85478     try {
85479       delete arg1;
85480     } catch (std::out_of_range& e) {
85481       {
85482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (std::exception& e) {
85485       {
85486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85487       };
85488     } catch (...) {
85489       {
85490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85491       };
85492     }
85493   }
85494 }
85495
85496
85497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85498   void * jresult ;
85499   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85500   Dali::Toolkit::Visual::Base *result = 0 ;
85501
85502   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85503   if (!arg1) {
85504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85505     return 0;
85506   }
85507   {
85508     try {
85509       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85510     } catch (std::out_of_range& e) {
85511       {
85512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85513       };
85514     } catch (std::exception& e) {
85515       {
85516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85517       };
85518     } catch (...) {
85519       {
85520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85521       };
85522     }
85523   }
85524   jresult = (void *)result;
85525   return jresult;
85526 }
85527
85528
85529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85530   void * jresult ;
85531   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85532   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85533   Dali::Toolkit::Visual::Base *result = 0 ;
85534
85535   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85536   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85537   if (!arg2) {
85538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85539     return 0;
85540   }
85541   {
85542     try {
85543       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85544     } catch (std::out_of_range& e) {
85545       {
85546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (std::exception& e) {
85549       {
85550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85555       };
85556     }
85557   }
85558   jresult = (void *)result;
85559   return jresult;
85560 }
85561
85562
85563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85564   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85565   std::string *arg2 = 0 ;
85566
85567   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85568   if (!jarg2) {
85569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85570     return ;
85571   }
85572   std::string arg2_str(jarg2);
85573   arg2 = &arg2_str;
85574   {
85575     try {
85576       (arg1)->SetName((std::string const &)*arg2);
85577     } catch (std::out_of_range& e) {
85578       {
85579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85580       };
85581     } catch (std::exception& e) {
85582       {
85583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85584       };
85585     } catch (...) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85588       };
85589     }
85590   }
85591
85592   //argout typemap for const std::string&
85593
85594 }
85595
85596
85597 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85598   char * jresult ;
85599   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85600   std::string *result = 0 ;
85601
85602   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85603   {
85604     try {
85605       result = (std::string *) &(arg1)->GetName();
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (...) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85617       };
85618     }
85619   }
85620   jresult = SWIG_csharp_string_callback(result->c_str());
85621   return jresult;
85622 }
85623
85624
85625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85626   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85627   Dali::Property::Map *arg2 = 0 ;
85628   Dali::Size arg3 ;
85629   Dali::Size *argp3 ;
85630
85631   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85632   arg2 = (Dali::Property::Map *)jarg2;
85633   if (!arg2) {
85634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85635     return ;
85636   }
85637   argp3 = (Dali::Size *)jarg3;
85638   if (!argp3) {
85639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85640     return ;
85641   }
85642   arg3 = *argp3;
85643   {
85644     try {
85645       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85646     } catch (std::out_of_range& e) {
85647       {
85648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85649       };
85650     } catch (std::exception& e) {
85651       {
85652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85653       };
85654     } catch (...) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85657       };
85658     }
85659   }
85660 }
85661
85662
85663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85664   float jresult ;
85665   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85666   float arg2 ;
85667   float result;
85668
85669   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85670   arg2 = (float)jarg2;
85671   {
85672     try {
85673       result = (float)(arg1)->GetHeightForWidth(arg2);
85674     } catch (std::out_of_range& e) {
85675       {
85676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85677       };
85678     } catch (std::exception& e) {
85679       {
85680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85681       };
85682     } catch (...) {
85683       {
85684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85685       };
85686     }
85687   }
85688   jresult = result;
85689   return jresult;
85690 }
85691
85692
85693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85694   float jresult ;
85695   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85696   float arg2 ;
85697   float result;
85698
85699   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85700   arg2 = (float)jarg2;
85701   {
85702     try {
85703       result = (float)(arg1)->GetWidthForHeight(arg2);
85704     } catch (std::out_of_range& e) {
85705       {
85706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85707       };
85708     } catch (std::exception& e) {
85709       {
85710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85711       };
85712     } catch (...) {
85713       {
85714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85715       };
85716     }
85717   }
85718   jresult = result;
85719   return jresult;
85720 }
85721
85722
85723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85724   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85725   Dali::Vector2 *arg2 = 0 ;
85726
85727   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85728   arg2 = (Dali::Vector2 *)jarg2;
85729   if (!arg2) {
85730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85731     return ;
85732   }
85733   {
85734     try {
85735       (arg1)->GetNaturalSize(*arg2);
85736     } catch (std::out_of_range& e) {
85737       {
85738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85739       };
85740     } catch (std::exception& e) {
85741       {
85742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85743       };
85744     } catch (...) {
85745       {
85746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85747       };
85748     }
85749   }
85750 }
85751
85752
85753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85754   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85755   float arg2 ;
85756
85757   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85758   arg2 = (int)jarg2;
85759   {
85760     try {
85761       (arg1)->SetDepthIndex(arg2);
85762     } catch (std::out_of_range& e) {
85763       {
85764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85765       };
85766     } catch (std::exception& e) {
85767       {
85768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85773       };
85774     }
85775   }
85776 }
85777
85778
85779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85780   int jresult ;
85781   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85782   int result;
85783
85784   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85785   {
85786     try {
85787       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85788     } catch (std::out_of_range& e) {
85789       {
85790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (std::exception& e) {
85793       {
85794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802   jresult = result;
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85808   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85809   Dali::Property::Map *arg2 = 0 ;
85810
85811   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85812   arg2 = (Dali::Property::Map *)jarg2;
85813   if (!arg2) {
85814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85815     return ;
85816   }
85817   {
85818     try {
85819       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85820     } catch (std::out_of_range& e) {
85821       {
85822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85823       };
85824     } catch (std::exception& e) {
85825       {
85826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85827       };
85828     } catch (...) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85831       };
85832     }
85833   }
85834 }
85835
85836
85837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85838   void * jresult ;
85839   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85840   Dali::Toolkit::Visual::Base *result = 0 ;
85841
85842   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85843   {
85844     try {
85845       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85846     } catch (std::out_of_range& e) {
85847       {
85848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85849       };
85850     } catch (std::exception& e) {
85851       {
85852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (...) {
85855       {
85856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85857       };
85858     }
85859   }
85860   jresult = (void *)result;
85861   return jresult;
85862 }
85863
85864
85865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85866   void * jresult ;
85867   Dali::Toolkit::VisualFactory result;
85868
85869   {
85870     try {
85871       result = Dali::Toolkit::VisualFactory::Get();
85872     } catch (std::out_of_range& e) {
85873       {
85874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85875       };
85876     } catch (std::exception& e) {
85877       {
85878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85879       };
85880     } catch (...) {
85881       {
85882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85883       };
85884     }
85885   }
85886   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85887   return jresult;
85888 }
85889
85890
85891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85892   void * jresult ;
85893   Dali::Toolkit::VisualFactory *result = 0 ;
85894
85895   {
85896     try {
85897       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85898     } catch (std::out_of_range& e) {
85899       {
85900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85901       };
85902     } catch (std::exception& e) {
85903       {
85904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85905       };
85906     } catch (...) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85909       };
85910     }
85911   }
85912   jresult = (void *)result;
85913   return jresult;
85914 }
85915
85916
85917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85918   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85919
85920   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85921   {
85922     try {
85923       delete arg1;
85924     } catch (std::out_of_range& e) {
85925       {
85926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85927       };
85928     } catch (std::exception& e) {
85929       {
85930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85931       };
85932     } catch (...) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85935       };
85936     }
85937   }
85938 }
85939
85940
85941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85942   void * jresult ;
85943   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85944   Dali::Toolkit::VisualFactory *result = 0 ;
85945
85946   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85947   if (!arg1) {
85948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85949     return 0;
85950   }
85951   {
85952     try {
85953       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85954     } catch (std::out_of_range& e) {
85955       {
85956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85957       };
85958     } catch (std::exception& e) {
85959       {
85960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85961       };
85962     } catch (...) {
85963       {
85964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85965       };
85966     }
85967   }
85968   jresult = (void *)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85974   void * jresult ;
85975   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85976   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85977   Dali::Toolkit::VisualFactory *result = 0 ;
85978
85979   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85980   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85981   if (!arg2) {
85982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85983     return 0;
85984   }
85985   {
85986     try {
85987       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85988     } catch (std::out_of_range& e) {
85989       {
85990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85991       };
85992     } catch (std::exception& e) {
85993       {
85994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (...) {
85997       {
85998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85999       };
86000     }
86001   }
86002   jresult = (void *)result;
86003   return jresult;
86004 }
86005
86006
86007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86008   void * jresult ;
86009   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86010   Dali::Property::Map *arg2 = 0 ;
86011   Dali::Toolkit::Visual::Base result;
86012
86013   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86014   arg2 = (Dali::Property::Map *)jarg2;
86015   if (!arg2) {
86016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86017     return 0;
86018   }
86019   {
86020     try {
86021       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (...) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86033       };
86034     }
86035   }
86036   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86037   return jresult;
86038 }
86039
86040
86041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
86042   void * jresult ;
86043   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86044   Dali::Image *arg2 = 0 ;
86045   Dali::Toolkit::Visual::Base result;
86046
86047   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86048   arg2 = (Dali::Image *)jarg2;
86049   if (!arg2) {
86050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
86051     return 0;
86052   }
86053   {
86054     try {
86055       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
86056     } catch (std::out_of_range& e) {
86057       {
86058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86059       };
86060     } catch (std::exception& e) {
86061       {
86062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86063       };
86064     } catch (...) {
86065       {
86066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86067       };
86068     }
86069   }
86070   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86071   return jresult;
86072 }
86073
86074
86075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86076   void * jresult ;
86077   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86078   std::string *arg2 = 0 ;
86079   Dali::ImageDimensions arg3 ;
86080   Dali::ImageDimensions *argp3 ;
86081   Dali::Toolkit::Visual::Base result;
86082
86083   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86084   if (!jarg2) {
86085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86086     return 0;
86087   }
86088   std::string arg2_str(jarg2);
86089   arg2 = &arg2_str;
86090   argp3 = (Dali::ImageDimensions *)jarg3;
86091   if (!argp3) {
86092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86093     return 0;
86094   }
86095   arg3 = *argp3;
86096   {
86097     try {
86098       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86099     } catch (std::out_of_range& e) {
86100       {
86101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86102       };
86103     } catch (std::exception& e) {
86104       {
86105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86106       };
86107     } catch (...) {
86108       {
86109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86110       };
86111     }
86112   }
86113   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86114
86115   //argout typemap for const std::string&
86116
86117   return jresult;
86118 }
86119
86120
86121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86122   void * jresult ;
86123   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86124
86125   {
86126     try {
86127       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86128     } catch (std::out_of_range& e) {
86129       {
86130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86131       };
86132     } catch (std::exception& e) {
86133       {
86134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (...) {
86137       {
86138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86139       };
86140     }
86141   }
86142   jresult = (void *)result;
86143   return jresult;
86144 }
86145
86146
86147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86148   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86149
86150   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86151   {
86152     try {
86153       delete arg1;
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86161       };
86162     } catch (...) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86165       };
86166     }
86167   }
86168 }
86169
86170
86171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86172   void * jresult ;
86173   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86174   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86175
86176   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86177   if (!arg1) {
86178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86179     return 0;
86180   }
86181   {
86182     try {
86183       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86184     } catch (std::out_of_range& e) {
86185       {
86186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (std::exception& e) {
86189       {
86190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86191       };
86192     } catch (...) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86195       };
86196     }
86197   }
86198   jresult = (void *)result;
86199   return jresult;
86200 }
86201
86202
86203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86204   void * jresult ;
86205   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86206   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86207   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86208
86209   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86210   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86211   if (!arg2) {
86212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86213     return 0;
86214   }
86215   {
86216     try {
86217       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86229       };
86230     }
86231   }
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86238   void * jresult ;
86239   Dali::Toolkit::AsyncImageLoader result;
86240
86241   {
86242     try {
86243       result = Dali::Toolkit::AsyncImageLoader::New();
86244     } catch (std::out_of_range& e) {
86245       {
86246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86247       };
86248     } catch (std::exception& e) {
86249       {
86250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86251       };
86252     } catch (...) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86255       };
86256     }
86257   }
86258   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86259   return jresult;
86260 }
86261
86262
86263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86264   void * jresult ;
86265   Dali::BaseHandle arg1 ;
86266   Dali::BaseHandle *argp1 ;
86267   Dali::Toolkit::AsyncImageLoader result;
86268
86269   argp1 = (Dali::BaseHandle *)jarg1;
86270   if (!argp1) {
86271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86272     return 0;
86273   }
86274   arg1 = *argp1;
86275   {
86276     try {
86277       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86278     } catch (std::out_of_range& e) {
86279       {
86280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (std::exception& e) {
86283       {
86284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86285       };
86286     } catch (...) {
86287       {
86288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86289       };
86290     }
86291   }
86292   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86293   return jresult;
86294 }
86295
86296
86297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86298   unsigned int jresult ;
86299   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86300   std::string *arg2 = 0 ;
86301   uint32_t result;
86302
86303   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86304   if (!jarg2) {
86305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86306     return 0;
86307   }
86308   std::string arg2_str(jarg2);
86309   arg2 = &arg2_str;
86310   {
86311     try {
86312       result = (arg1)->Load((std::string const &)*arg2);
86313     } catch (std::out_of_range& e) {
86314       {
86315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86316       };
86317     } catch (std::exception& e) {
86318       {
86319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86320       };
86321     } catch (...) {
86322       {
86323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86324       };
86325     }
86326   }
86327   jresult = result;
86328
86329   //argout typemap for const std::string&
86330
86331   return jresult;
86332 }
86333
86334
86335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86336   unsigned int jresult ;
86337   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86338   std::string *arg2 = 0 ;
86339   Dali::ImageDimensions arg3 ;
86340   Dali::ImageDimensions *argp3 ;
86341   uint32_t result;
86342
86343   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86344   if (!jarg2) {
86345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86346     return 0;
86347   }
86348   std::string arg2_str(jarg2);
86349   arg2 = &arg2_str;
86350   argp3 = (Dali::ImageDimensions *)jarg3;
86351   if (!argp3) {
86352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86353     return 0;
86354   }
86355   arg3 = *argp3;
86356   {
86357     try {
86358       result = (arg1)->Load((std::string const &)*arg2,arg3);
86359     } catch (std::out_of_range& e) {
86360       {
86361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86362       };
86363     } catch (std::exception& e) {
86364       {
86365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86366       };
86367     } catch (...) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86370       };
86371     }
86372   }
86373   jresult = result;
86374
86375   //argout typemap for const std::string&
86376
86377   return jresult;
86378 }
86379
86380
86381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86382   unsigned int jresult ;
86383   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86384   std::string *arg2 = 0 ;
86385   Dali::ImageDimensions arg3 ;
86386   Dali::FittingMode::Type arg4 ;
86387   Dali::SamplingMode::Type arg5 ;
86388   bool arg6 ;
86389   Dali::ImageDimensions *argp3 ;
86390   uint32_t result;
86391
86392   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86393   if (!jarg2) {
86394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86395     return 0;
86396   }
86397   std::string arg2_str(jarg2);
86398   arg2 = &arg2_str;
86399   argp3 = (Dali::ImageDimensions *)jarg3;
86400   if (!argp3) {
86401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86402     return 0;
86403   }
86404   arg3 = *argp3;
86405   arg4 = (Dali::FittingMode::Type)jarg4;
86406   arg5 = (Dali::SamplingMode::Type)jarg5;
86407   arg6 = jarg6 ? true : false;
86408   {
86409     try {
86410       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86411     } catch (std::out_of_range& e) {
86412       {
86413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86414       };
86415     } catch (std::exception& e) {
86416       {
86417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86418       };
86419     } catch (...) {
86420       {
86421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86422       };
86423     }
86424   }
86425   jresult = result;
86426
86427   //argout typemap for const std::string&
86428
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86434   unsigned int jresult ;
86435   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86436   uint32_t arg2 ;
86437   bool result;
86438
86439   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86440   arg2 = (uint32_t)jarg2;
86441   {
86442     try {
86443       result = (bool)(arg1)->Cancel(arg2);
86444     } catch (std::out_of_range& e) {
86445       {
86446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86447       };
86448     } catch (std::exception& e) {
86449       {
86450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86451       };
86452     } catch (...) {
86453       {
86454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86455       };
86456     }
86457   }
86458   jresult = result;
86459   return jresult;
86460 }
86461
86462
86463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86464   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86465
86466   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86467   {
86468     try {
86469       (arg1)->CancelAll();
86470     } catch (std::out_of_range& e) {
86471       {
86472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86473       };
86474     } catch (std::exception& e) {
86475       {
86476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86477       };
86478     } catch (...) {
86479       {
86480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86481       };
86482     }
86483   }
86484 }
86485
86486
86487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86488   void * jresult ;
86489   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86490   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86491
86492   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86493   {
86494     try {
86495       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86496     } catch (std::out_of_range& e) {
86497       {
86498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86499       };
86500     } catch (std::exception& e) {
86501       {
86502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (...) {
86505       {
86506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86507       };
86508     }
86509   }
86510   jresult = (void *)result;
86511   return jresult;
86512 }
86513
86514
86515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86516   void * jresult ;
86517   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86518   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86519
86520   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86521   {
86522     try {
86523       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86524     } catch (std::out_of_range& e) {
86525       {
86526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86527       };
86528     } catch (std::exception& e) {
86529       {
86530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (...) {
86533       {
86534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86535       };
86536     }
86537   }
86538   jresult = (void *)result;
86539   return jresult;
86540 }
86541
86542
86543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86544   void * jresult ;
86545   std::string *arg1 = 0 ;
86546   Dali::PixelData result;
86547
86548   if (!jarg1) {
86549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86550     return 0;
86551   }
86552   std::string arg1_str(jarg1);
86553   arg1 = &arg1_str;
86554   {
86555     try {
86556       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86557     } catch (std::out_of_range& e) {
86558       {
86559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86560       };
86561     } catch (std::exception& e) {
86562       {
86563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (...) {
86566       {
86567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86568       };
86569     }
86570   }
86571   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86572
86573   //argout typemap for const std::string&
86574
86575   return jresult;
86576 }
86577
86578
86579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86580   void * jresult ;
86581   std::string *arg1 = 0 ;
86582   Dali::ImageDimensions arg2 ;
86583   Dali::ImageDimensions *argp2 ;
86584   Dali::PixelData result;
86585
86586   if (!jarg1) {
86587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86588     return 0;
86589   }
86590   std::string arg1_str(jarg1);
86591   arg1 = &arg1_str;
86592   argp2 = (Dali::ImageDimensions *)jarg2;
86593   if (!argp2) {
86594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86595     return 0;
86596   }
86597   arg2 = *argp2;
86598   {
86599     try {
86600       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86601     } catch (std::out_of_range& e) {
86602       {
86603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86604       };
86605     } catch (std::exception& e) {
86606       {
86607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86608       };
86609     } catch (...) {
86610       {
86611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86612       };
86613     }
86614   }
86615   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86616
86617   //argout typemap for const std::string&
86618
86619   return jresult;
86620 }
86621
86622
86623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86624   void * jresult ;
86625   std::string *arg1 = 0 ;
86626   Dali::ImageDimensions arg2 ;
86627   Dali::FittingMode::Type arg3 ;
86628   Dali::SamplingMode::Type arg4 ;
86629   bool arg5 ;
86630   Dali::ImageDimensions *argp2 ;
86631   Dali::PixelData result;
86632
86633   if (!jarg1) {
86634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86635     return 0;
86636   }
86637   std::string arg1_str(jarg1);
86638   arg1 = &arg1_str;
86639   argp2 = (Dali::ImageDimensions *)jarg2;
86640   if (!argp2) {
86641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86642     return 0;
86643   }
86644   arg2 = *argp2;
86645   arg3 = (Dali::FittingMode::Type)jarg3;
86646   arg4 = (Dali::SamplingMode::Type)jarg4;
86647   arg5 = jarg5 ? true : false;
86648   {
86649     try {
86650       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86651     } catch (std::out_of_range& e) {
86652       {
86653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86654       };
86655     } catch (std::exception& e) {
86656       {
86657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86658       };
86659     } catch (...) {
86660       {
86661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86662       };
86663     }
86664   }
86665   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86666
86667   //argout typemap for const std::string&
86668
86669   return jresult;
86670 }
86671
86672
86673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86674   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86675
86676   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86677   {
86678     try {
86679       delete arg1;
86680     } catch (std::out_of_range& e) {
86681       {
86682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86683       };
86684     } catch (std::exception& e) {
86685       {
86686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86687       };
86688     } catch (...) {
86689       {
86690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86691       };
86692     }
86693   }
86694 }
86695
86696
86697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86698   void * jresult ;
86699   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86700   Dali::Actor arg2 ;
86701   Dali::Actor arg3 ;
86702   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86703   Dali::Actor *argp2 ;
86704   Dali::Actor *argp3 ;
86705   Dali::Actor result;
86706
86707   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86708   argp2 = (Dali::Actor *)jarg2;
86709   if (!argp2) {
86710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86711     return 0;
86712   }
86713   arg2 = *argp2;
86714   argp3 = (Dali::Actor *)jarg3;
86715   if (!argp3) {
86716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86717     return 0;
86718   }
86719   arg3 = *argp3;
86720   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86721   {
86722     try {
86723       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86724     } catch (std::out_of_range& e) {
86725       {
86726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (std::exception& e) {
86729       {
86730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (...) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86735       };
86736     }
86737   }
86738   jresult = new Dali::Actor((const Dali::Actor &)result);
86739   return jresult;
86740 }
86741
86742
86743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86744   void * jresult ;
86745   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86746
86747   {
86748     try {
86749       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86750     } catch (std::out_of_range& e) {
86751       {
86752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86753       };
86754     } catch (std::exception& e) {
86755       {
86756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86757       };
86758     } catch (...) {
86759       {
86760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86761       };
86762     }
86763   }
86764   jresult = (void *)result;
86765   return jresult;
86766 }
86767
86768
86769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86770   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86771   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86772   if (director) {
86773     director->swig_connect_director(callback0);
86774   }
86775 }
86776
86777
86778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86779   KeyboardFocusManager arg1 ;
86780   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86781   KeyboardFocusManager *argp1 ;
86782
86783   argp1 = (KeyboardFocusManager *)jarg1;
86784   if (!argp1) {
86785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86786     return ;
86787   }
86788   arg1 = *argp1;
86789   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86790   if (!arg2) {
86791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86792     return ;
86793   }
86794   {
86795     try {
86796       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86797     } catch (std::out_of_range& e) {
86798       {
86799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86800       };
86801     } catch (std::exception& e) {
86802       {
86803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86804       };
86805     } catch (...) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86808       };
86809     }
86810   }
86811 }
86812
86813
86814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86815   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86816
86817   arg1 = (std::vector< unsigned int > *)jarg1;
86818   {
86819     try {
86820       (arg1)->clear();
86821     } catch (std::out_of_range& e) {
86822       {
86823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86824       };
86825     } catch (std::exception& e) {
86826       {
86827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86828       };
86829     } catch (...) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86832       };
86833     }
86834   }
86835 }
86836
86837
86838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86839   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86840   unsigned int *arg2 = 0 ;
86841   unsigned int temp2 ;
86842
86843   arg1 = (std::vector< unsigned int > *)jarg1;
86844   temp2 = (unsigned int)jarg2;
86845   arg2 = &temp2;
86846   {
86847     try {
86848       (arg1)->push_back((unsigned int const &)*arg2);
86849     } catch (std::out_of_range& e) {
86850       {
86851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86852       };
86853     } catch (std::exception& e) {
86854       {
86855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86856       };
86857     } catch (...) {
86858       {
86859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86860       };
86861     }
86862   }
86863 }
86864
86865
86866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86867   unsigned long jresult ;
86868   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86869   std::vector< unsigned int >::size_type result;
86870
86871   arg1 = (std::vector< unsigned int > *)jarg1;
86872   {
86873     try {
86874       result = ((std::vector< unsigned int > const *)arg1)->size();
86875     } catch (std::out_of_range& e) {
86876       {
86877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86878       };
86879     } catch (std::exception& e) {
86880       {
86881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86882       };
86883     } catch (...) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86886       };
86887     }
86888   }
86889   jresult = (unsigned long)result;
86890   return jresult;
86891 }
86892
86893
86894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86895   unsigned long jresult ;
86896   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86897   std::vector< unsigned int >::size_type result;
86898
86899   arg1 = (std::vector< unsigned int > *)jarg1;
86900   {
86901     try {
86902       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86910       };
86911     } catch (...) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86914       };
86915     }
86916   }
86917   jresult = (unsigned long)result;
86918   return jresult;
86919 }
86920
86921
86922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86923   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86924   std::vector< unsigned int >::size_type arg2 ;
86925
86926   arg1 = (std::vector< unsigned int > *)jarg1;
86927   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86928   {
86929     try {
86930       (arg1)->reserve(arg2);
86931     } catch (std::out_of_range& e) {
86932       {
86933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86934       };
86935     } catch (std::exception& e) {
86936       {
86937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86942       };
86943     }
86944   }
86945 }
86946
86947
86948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86949   void * jresult ;
86950   std::vector< unsigned int > *result = 0 ;
86951
86952   {
86953     try {
86954       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86955     } catch (std::out_of_range& e) {
86956       {
86957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86958       };
86959     } catch (std::exception& e) {
86960       {
86961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86966       };
86967     }
86968   }
86969   jresult = (void *)result;
86970   return jresult;
86971 }
86972
86973
86974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86975   void * jresult ;
86976   std::vector< unsigned int > *arg1 = 0 ;
86977   std::vector< unsigned int > *result = 0 ;
86978
86979   arg1 = (std::vector< unsigned int > *)jarg1;
86980   if (!arg1) {
86981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86982     return 0;
86983   }
86984   {
86985     try {
86986       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86987     } catch (std::out_of_range& e) {
86988       {
86989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86990       };
86991     } catch (std::exception& e) {
86992       {
86993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86994       };
86995     } catch (...) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86998       };
86999     }
87000   }
87001   jresult = (void *)result;
87002   return jresult;
87003 }
87004
87005
87006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87007   void * jresult ;
87008   int arg1 ;
87009   std::vector< unsigned int > *result = 0 ;
87010
87011   arg1 = (int)jarg1;
87012   {
87013     try {
87014       try {
87015         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87016       }
87017       catch(std::out_of_range &_e) {
87018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87019         return 0;
87020       }
87021
87022     } catch (std::out_of_range& e) {
87023       {
87024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87025       };
87026     } catch (std::exception& e) {
87027       {
87028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (...) {
87031       {
87032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87033       };
87034     }
87035   }
87036   jresult = (void *)result;
87037   return jresult;
87038 }
87039
87040
87041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87042   unsigned int jresult ;
87043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87044   int arg2 ;
87045   unsigned int result;
87046
87047   arg1 = (std::vector< unsigned int > *)jarg1;
87048   arg2 = (int)jarg2;
87049   {
87050     try {
87051       try {
87052         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87053       }
87054       catch(std::out_of_range &_e) {
87055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87056         return 0;
87057       }
87058
87059     } catch (std::out_of_range& e) {
87060       {
87061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87062       };
87063     } catch (std::exception& e) {
87064       {
87065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (...) {
87068       {
87069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87070       };
87071     }
87072   }
87073   jresult = result;
87074   return jresult;
87075 }
87076
87077
87078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87079   unsigned int jresult ;
87080   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87081   int arg2 ;
87082   unsigned int *result = 0 ;
87083
87084   arg1 = (std::vector< unsigned int > *)jarg1;
87085   arg2 = (int)jarg2;
87086   {
87087     try {
87088       try {
87089         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87090       }
87091       catch(std::out_of_range &_e) {
87092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87093         return 0;
87094       }
87095
87096     } catch (std::out_of_range& e) {
87097       {
87098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87099       };
87100     } catch (std::exception& e) {
87101       {
87102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (...) {
87105       {
87106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87107       };
87108     }
87109   }
87110   jresult = *result;
87111   return jresult;
87112 }
87113
87114
87115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87116   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87117   int arg2 ;
87118   unsigned int *arg3 = 0 ;
87119   unsigned int temp3 ;
87120
87121   arg1 = (std::vector< unsigned int > *)jarg1;
87122   arg2 = (int)jarg2;
87123   temp3 = (unsigned int)jarg3;
87124   arg3 = &temp3;
87125   {
87126     try {
87127       try {
87128         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87129       }
87130       catch(std::out_of_range &_e) {
87131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87132         return ;
87133       }
87134
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87142       };
87143     } catch (...) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87146       };
87147     }
87148   }
87149 }
87150
87151
87152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87153   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87154   std::vector< unsigned int > *arg2 = 0 ;
87155
87156   arg1 = (std::vector< unsigned int > *)jarg1;
87157   arg2 = (std::vector< unsigned int > *)jarg2;
87158   if (!arg2) {
87159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87160     return ;
87161   }
87162   {
87163     try {
87164       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87165     } catch (std::out_of_range& e) {
87166       {
87167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87168       };
87169     } catch (std::exception& e) {
87170       {
87171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87172       };
87173     } catch (...) {
87174       {
87175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87176       };
87177     }
87178   }
87179 }
87180
87181
87182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87183   void * jresult ;
87184   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87185   int arg2 ;
87186   int arg3 ;
87187   std::vector< unsigned int > *result = 0 ;
87188
87189   arg1 = (std::vector< unsigned int > *)jarg1;
87190   arg2 = (int)jarg2;
87191   arg3 = (int)jarg3;
87192   {
87193     try {
87194       try {
87195         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87196       }
87197       catch(std::out_of_range &_e) {
87198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87199         return 0;
87200       }
87201       catch(std::invalid_argument &_e) {
87202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87203         return 0;
87204       }
87205
87206     } catch (std::out_of_range& e) {
87207       {
87208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87209       };
87210     } catch (std::exception& e) {
87211       {
87212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87213       };
87214     } catch (...) {
87215       {
87216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87217       };
87218     }
87219   }
87220   jresult = (void *)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87226   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87227   int arg2 ;
87228   unsigned int *arg3 = 0 ;
87229   unsigned int temp3 ;
87230
87231   arg1 = (std::vector< unsigned int > *)jarg1;
87232   arg2 = (int)jarg2;
87233   temp3 = (unsigned int)jarg3;
87234   arg3 = &temp3;
87235   {
87236     try {
87237       try {
87238         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87239       }
87240       catch(std::out_of_range &_e) {
87241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87242         return ;
87243       }
87244
87245     } catch (std::out_of_range& e) {
87246       {
87247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87248       };
87249     } catch (std::exception& e) {
87250       {
87251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87252       };
87253     } catch (...) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87256       };
87257     }
87258   }
87259 }
87260
87261
87262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87264   int arg2 ;
87265   std::vector< unsigned int > *arg3 = 0 ;
87266
87267   arg1 = (std::vector< unsigned int > *)jarg1;
87268   arg2 = (int)jarg2;
87269   arg3 = (std::vector< unsigned int > *)jarg3;
87270   if (!arg3) {
87271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87272     return ;
87273   }
87274   {
87275     try {
87276       try {
87277         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87278       }
87279       catch(std::out_of_range &_e) {
87280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87281         return ;
87282       }
87283
87284     } catch (std::out_of_range& e) {
87285       {
87286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87287       };
87288     } catch (std::exception& e) {
87289       {
87290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (...) {
87293       {
87294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87295       };
87296     }
87297   }
87298 }
87299
87300
87301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87302   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87303   int arg2 ;
87304
87305   arg1 = (std::vector< unsigned int > *)jarg1;
87306   arg2 = (int)jarg2;
87307   {
87308     try {
87309       try {
87310         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87311       }
87312       catch(std::out_of_range &_e) {
87313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87314         return ;
87315       }
87316
87317     } catch (std::out_of_range& e) {
87318       {
87319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87320       };
87321     } catch (std::exception& e) {
87322       {
87323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (...) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87328       };
87329     }
87330   }
87331 }
87332
87333
87334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87335   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87336   int arg2 ;
87337   int arg3 ;
87338
87339   arg1 = (std::vector< unsigned int > *)jarg1;
87340   arg2 = (int)jarg2;
87341   arg3 = (int)jarg3;
87342   {
87343     try {
87344       try {
87345         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87346       }
87347       catch(std::out_of_range &_e) {
87348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87349         return ;
87350       }
87351       catch(std::invalid_argument &_e) {
87352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87353         return ;
87354       }
87355
87356     } catch (std::out_of_range& e) {
87357       {
87358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87359       };
87360     } catch (std::exception& e) {
87361       {
87362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87363       };
87364     } catch (...) {
87365       {
87366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87367       };
87368     }
87369   }
87370 }
87371
87372
87373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87374   void * jresult ;
87375   unsigned int *arg1 = 0 ;
87376   int arg2 ;
87377   unsigned int temp1 ;
87378   std::vector< unsigned int > *result = 0 ;
87379
87380   temp1 = (unsigned int)jarg1;
87381   arg1 = &temp1;
87382   arg2 = (int)jarg2;
87383   {
87384     try {
87385       try {
87386         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87387       }
87388       catch(std::out_of_range &_e) {
87389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87390         return 0;
87391       }
87392
87393     } catch (std::out_of_range& e) {
87394       {
87395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87396       };
87397     } catch (std::exception& e) {
87398       {
87399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87400       };
87401     } catch (...) {
87402       {
87403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87404       };
87405     }
87406   }
87407   jresult = (void *)result;
87408   return jresult;
87409 }
87410
87411
87412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87413   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87414
87415   arg1 = (std::vector< unsigned int > *)jarg1;
87416   {
87417     try {
87418       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87419     } catch (std::out_of_range& e) {
87420       {
87421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87422       };
87423     } catch (std::exception& e) {
87424       {
87425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87426       };
87427     } catch (...) {
87428       {
87429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87430       };
87431     }
87432   }
87433 }
87434
87435
87436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87437   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87438   int arg2 ;
87439   int arg3 ;
87440
87441   arg1 = (std::vector< unsigned int > *)jarg1;
87442   arg2 = (int)jarg2;
87443   arg3 = (int)jarg3;
87444   {
87445     try {
87446       try {
87447         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87448       }
87449       catch(std::out_of_range &_e) {
87450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87451         return ;
87452       }
87453       catch(std::invalid_argument &_e) {
87454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87455         return ;
87456       }
87457
87458     } catch (std::out_of_range& e) {
87459       {
87460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87461       };
87462     } catch (std::exception& e) {
87463       {
87464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87465       };
87466     } catch (...) {
87467       {
87468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87469       };
87470     }
87471   }
87472 }
87473
87474
87475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87476   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87477   int arg2 ;
87478   std::vector< unsigned int > *arg3 = 0 ;
87479
87480   arg1 = (std::vector< unsigned int > *)jarg1;
87481   arg2 = (int)jarg2;
87482   arg3 = (std::vector< unsigned int > *)jarg3;
87483   if (!arg3) {
87484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87485     return ;
87486   }
87487   {
87488     try {
87489       try {
87490         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87491       }
87492       catch(std::out_of_range &_e) {
87493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87494         return ;
87495       }
87496
87497     } catch (std::out_of_range& e) {
87498       {
87499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87500       };
87501     } catch (std::exception& e) {
87502       {
87503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87504       };
87505     } catch (...) {
87506       {
87507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87508       };
87509     }
87510   }
87511 }
87512
87513
87514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87515   unsigned int jresult ;
87516   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87517   unsigned int *arg2 = 0 ;
87518   unsigned int temp2 ;
87519   bool result;
87520
87521   arg1 = (std::vector< unsigned int > *)jarg1;
87522   temp2 = (unsigned int)jarg2;
87523   arg2 = &temp2;
87524   {
87525     try {
87526       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87527     } catch (std::out_of_range& e) {
87528       {
87529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87530       };
87531     } catch (std::exception& e) {
87532       {
87533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87534       };
87535     } catch (...) {
87536       {
87537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87538       };
87539     }
87540   }
87541   jresult = result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87547   int jresult ;
87548   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87549   unsigned int *arg2 = 0 ;
87550   unsigned int temp2 ;
87551   int result;
87552
87553   arg1 = (std::vector< unsigned int > *)jarg1;
87554   temp2 = (unsigned int)jarg2;
87555   arg2 = &temp2;
87556   {
87557     try {
87558       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87559     } catch (std::out_of_range& e) {
87560       {
87561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87562       };
87563     } catch (std::exception& e) {
87564       {
87565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87566       };
87567     } catch (...) {
87568       {
87569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87570       };
87571     }
87572   }
87573   jresult = result;
87574   return jresult;
87575 }
87576
87577
87578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87579   int jresult ;
87580   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87581   unsigned int *arg2 = 0 ;
87582   unsigned int temp2 ;
87583   int result;
87584
87585   arg1 = (std::vector< unsigned int > *)jarg1;
87586   temp2 = (unsigned int)jarg2;
87587   arg2 = &temp2;
87588   {
87589     try {
87590       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87591     } catch (std::out_of_range& e) {
87592       {
87593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87594       };
87595     } catch (std::exception& e) {
87596       {
87597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87598       };
87599     } catch (...) {
87600       {
87601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87602       };
87603     }
87604   }
87605   jresult = result;
87606   return jresult;
87607 }
87608
87609
87610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87611   unsigned int jresult ;
87612   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87613   unsigned int *arg2 = 0 ;
87614   unsigned int temp2 ;
87615   bool result;
87616
87617   arg1 = (std::vector< unsigned int > *)jarg1;
87618   temp2 = (unsigned int)jarg2;
87619   arg2 = &temp2;
87620   {
87621     try {
87622       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87623     } catch (std::out_of_range& e) {
87624       {
87625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87626       };
87627     } catch (std::exception& e) {
87628       {
87629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87630       };
87631     } catch (...) {
87632       {
87633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87634       };
87635     }
87636   }
87637   jresult = result;
87638   return jresult;
87639 }
87640
87641
87642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87643   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87644
87645   arg1 = (std::vector< unsigned int > *)jarg1;
87646   {
87647     try {
87648       delete arg1;
87649     } catch (std::out_of_range& e) {
87650       {
87651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87652       };
87653     } catch (std::exception& e) {
87654       {
87655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87656       };
87657     } catch (...) {
87658       {
87659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87660       };
87661     }
87662   }
87663 }
87664
87665
87666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87667   void * jresult ;
87668   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87669
87670   {
87671     try {
87672       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87673     } catch (std::out_of_range& e) {
87674       {
87675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87676       };
87677     } catch (std::exception& e) {
87678       {
87679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87680       };
87681     } catch (...) {
87682       {
87683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87684       };
87685     }
87686   }
87687   jresult = (void *)result;
87688   return jresult;
87689 }
87690
87691
87692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87693   void * jresult ;
87694   unsigned int arg1 ;
87695   Dali::Actor arg2 ;
87696   Dali::Actor *argp2 ;
87697   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87698
87699   arg1 = (unsigned int)jarg1;
87700   argp2 = (Dali::Actor *)jarg2;
87701   if (!argp2) {
87702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87703     return 0;
87704   }
87705   arg2 = *argp2;
87706   {
87707     try {
87708       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87709     } catch (std::out_of_range& e) {
87710       {
87711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87712       };
87713     } catch (std::exception& e) {
87714       {
87715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87716       };
87717     } catch (...) {
87718       {
87719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87720       };
87721     }
87722   }
87723   jresult = (void *)result;
87724   return jresult;
87725 }
87726
87727
87728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87729   void * jresult ;
87730   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87731   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87732
87733   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87734   if (!arg1) {
87735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87736     return 0;
87737   }
87738   {
87739     try {
87740       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87741     } catch (std::out_of_range& e) {
87742       {
87743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87744       };
87745     } catch (std::exception& e) {
87746       {
87747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87748       };
87749     } catch (...) {
87750       {
87751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87752       };
87753     }
87754   }
87755   jresult = (void *)result;
87756   return jresult;
87757 }
87758
87759
87760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87761   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87762   unsigned int arg2 ;
87763
87764   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87765   arg2 = (unsigned int)jarg2;
87766   if (arg1) (arg1)->first = arg2;
87767 }
87768
87769
87770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87771   unsigned int jresult ;
87772   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87773   unsigned int result;
87774
87775   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87776   result = (unsigned int) ((arg1)->first);
87777   jresult = result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87783   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87784   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87785
87786   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87787   arg2 = (Dali::Actor *)jarg2;
87788   if (arg1) (arg1)->second = *arg2;
87789 }
87790
87791
87792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87793   void * jresult ;
87794   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87795   Dali::Actor *result = 0 ;
87796
87797   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87798   result = (Dali::Actor *)& ((arg1)->second);
87799   jresult = (void *)result;
87800   return jresult;
87801 }
87802
87803
87804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87805   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87806
87807   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87808   {
87809     try {
87810       delete arg1;
87811     } catch (std::out_of_range& e) {
87812       {
87813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87814       };
87815     } catch (std::exception& e) {
87816       {
87817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87818       };
87819     } catch (...) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87822       };
87823     }
87824   }
87825 }
87826
87827
87828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87829   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87830
87831   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87832   {
87833     try {
87834       (arg1)->clear();
87835     } catch (std::out_of_range& e) {
87836       {
87837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87838       };
87839     } catch (std::exception& e) {
87840       {
87841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87842       };
87843     } catch (...) {
87844       {
87845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87846       };
87847     }
87848   }
87849 }
87850
87851
87852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87853   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87854   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87855
87856   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87857   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87858   if (!arg2) {
87859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87860     return ;
87861   }
87862   {
87863     try {
87864       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87865     } catch (std::out_of_range& e) {
87866       {
87867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87868       };
87869     } catch (std::exception& e) {
87870       {
87871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87872       };
87873     } catch (...) {
87874       {
87875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87876       };
87877     }
87878   }
87879 }
87880
87881
87882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87883   unsigned long jresult ;
87884   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87885   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87886
87887   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87888   {
87889     try {
87890       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87891     } catch (std::out_of_range& e) {
87892       {
87893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87894       };
87895     } catch (std::exception& e) {
87896       {
87897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87898       };
87899     } catch (...) {
87900       {
87901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87902       };
87903     }
87904   }
87905   jresult = (unsigned long)result;
87906   return jresult;
87907 }
87908
87909
87910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87911   unsigned long jresult ;
87912   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87913   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87914
87915   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87916   {
87917     try {
87918       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87919     } catch (std::out_of_range& e) {
87920       {
87921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87922       };
87923     } catch (std::exception& e) {
87924       {
87925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87926       };
87927     } catch (...) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87930       };
87931     }
87932   }
87933   jresult = (unsigned long)result;
87934   return jresult;
87935 }
87936
87937
87938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87939   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87940   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87941
87942   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87943   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87944   {
87945     try {
87946       (arg1)->reserve(arg2);
87947     } catch (std::out_of_range& e) {
87948       {
87949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87950       };
87951     } catch (std::exception& e) {
87952       {
87953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87954       };
87955     } catch (...) {
87956       {
87957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87958       };
87959     }
87960   }
87961 }
87962
87963
87964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87965   void * jresult ;
87966   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87967
87968   {
87969     try {
87970       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87971     } catch (std::out_of_range& e) {
87972       {
87973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87974       };
87975     } catch (std::exception& e) {
87976       {
87977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87978       };
87979     } catch (...) {
87980       {
87981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87982       };
87983     }
87984   }
87985   jresult = (void *)result;
87986   return jresult;
87987 }
87988
87989
87990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87991   void * jresult ;
87992   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87993   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87994
87995   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87996   if (!arg1) {
87997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87998     return 0;
87999   }
88000   {
88001     try {
88002       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);
88003     } catch (std::out_of_range& e) {
88004       {
88005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88006       };
88007     } catch (std::exception& e) {
88008       {
88009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88010       };
88011     } catch (...) {
88012       {
88013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88014       };
88015     }
88016   }
88017   jresult = (void *)result;
88018   return jresult;
88019 }
88020
88021
88022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88023   void * jresult ;
88024   int arg1 ;
88025   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88026
88027   arg1 = (int)jarg1;
88028   {
88029     try {
88030       try {
88031         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);
88032       }
88033       catch(std::out_of_range &_e) {
88034         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88035         return 0;
88036       }
88037
88038     } catch (std::out_of_range& e) {
88039       {
88040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88041       };
88042     } catch (std::exception& e) {
88043       {
88044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88045       };
88046     } catch (...) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88049       };
88050     }
88051   }
88052   jresult = (void *)result;
88053   return jresult;
88054 }
88055
88056
88057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88058   void * jresult ;
88059   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88060   int arg2 ;
88061   std::pair< unsigned int,Dali::Actor > result;
88062
88063   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88064   arg2 = (int)jarg2;
88065   {
88066     try {
88067       try {
88068         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88069       }
88070       catch(std::out_of_range &_e) {
88071         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88072         return 0;
88073       }
88074
88075     } catch (std::out_of_range& e) {
88076       {
88077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88078       };
88079     } catch (std::exception& e) {
88080       {
88081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88082       };
88083     } catch (...) {
88084       {
88085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88086       };
88087     }
88088   }
88089   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88090   return jresult;
88091 }
88092
88093
88094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88095   void * jresult ;
88096   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88097   int arg2 ;
88098   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88099
88100   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88101   arg2 = (int)jarg2;
88102   {
88103     try {
88104       try {
88105         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88106       }
88107       catch(std::out_of_range &_e) {
88108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88109         return 0;
88110       }
88111
88112     } catch (std::out_of_range& e) {
88113       {
88114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88115       };
88116     } catch (std::exception& e) {
88117       {
88118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88119       };
88120     } catch (...) {
88121       {
88122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88123       };
88124     }
88125   }
88126   jresult = (void *)result;
88127   return jresult;
88128 }
88129
88130
88131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88132   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88133   int arg2 ;
88134   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88135
88136   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88137   arg2 = (int)jarg2;
88138   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88139   if (!arg3) {
88140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88141     return ;
88142   }
88143   {
88144     try {
88145       try {
88146         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);
88147       }
88148       catch(std::out_of_range &_e) {
88149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88150         return ;
88151       }
88152
88153     } catch (std::out_of_range& e) {
88154       {
88155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88156       };
88157     } catch (std::exception& e) {
88158       {
88159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88160       };
88161     } catch (...) {
88162       {
88163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88164       };
88165     }
88166   }
88167 }
88168
88169
88170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88171   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88172   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88173
88174   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88175   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88176   if (!arg2) {
88177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88178     return ;
88179   }
88180   {
88181     try {
88182       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);
88183     } catch (std::out_of_range& e) {
88184       {
88185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88186       };
88187     } catch (std::exception& e) {
88188       {
88189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88190       };
88191     } catch (...) {
88192       {
88193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88194       };
88195     }
88196   }
88197 }
88198
88199
88200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88201   void * jresult ;
88202   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88203   int arg2 ;
88204   int arg3 ;
88205   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88206
88207   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88208   arg2 = (int)jarg2;
88209   arg3 = (int)jarg3;
88210   {
88211     try {
88212       try {
88213         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);
88214       }
88215       catch(std::out_of_range &_e) {
88216         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88217         return 0;
88218       }
88219       catch(std::invalid_argument &_e) {
88220         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88221         return 0;
88222       }
88223
88224     } catch (std::out_of_range& e) {
88225       {
88226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88227       };
88228     } catch (std::exception& e) {
88229       {
88230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88231       };
88232     } catch (...) {
88233       {
88234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88235       };
88236     }
88237   }
88238   jresult = (void *)result;
88239   return jresult;
88240 }
88241
88242
88243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88244   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88245   int arg2 ;
88246   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88247
88248   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88249   arg2 = (int)jarg2;
88250   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88251   if (!arg3) {
88252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88253     return ;
88254   }
88255   {
88256     try {
88257       try {
88258         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);
88259       }
88260       catch(std::out_of_range &_e) {
88261         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88262         return ;
88263       }
88264
88265     } catch (std::out_of_range& e) {
88266       {
88267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88268       };
88269     } catch (std::exception& e) {
88270       {
88271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88272       };
88273     } catch (...) {
88274       {
88275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88276       };
88277     }
88278   }
88279 }
88280
88281
88282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88283   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88284   int arg2 ;
88285   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88286
88287   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88288   arg2 = (int)jarg2;
88289   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88290   if (!arg3) {
88291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88292     return ;
88293   }
88294   {
88295     try {
88296       try {
88297         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);
88298       }
88299       catch(std::out_of_range &_e) {
88300         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88301         return ;
88302       }
88303
88304     } catch (std::out_of_range& e) {
88305       {
88306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88307       };
88308     } catch (std::exception& e) {
88309       {
88310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88311       };
88312     } catch (...) {
88313       {
88314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88315       };
88316     }
88317   }
88318 }
88319
88320
88321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88322   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88323   int arg2 ;
88324
88325   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88326   arg2 = (int)jarg2;
88327   {
88328     try {
88329       try {
88330         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88331       }
88332       catch(std::out_of_range &_e) {
88333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88334         return ;
88335       }
88336
88337     } catch (std::out_of_range& e) {
88338       {
88339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88340       };
88341     } catch (std::exception& e) {
88342       {
88343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88344       };
88345     } catch (...) {
88346       {
88347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88348       };
88349     }
88350   }
88351 }
88352
88353
88354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88355   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88356   int arg2 ;
88357   int arg3 ;
88358
88359   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88360   arg2 = (int)jarg2;
88361   arg3 = (int)jarg3;
88362   {
88363     try {
88364       try {
88365         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88366       }
88367       catch(std::out_of_range &_e) {
88368         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88369         return ;
88370       }
88371       catch(std::invalid_argument &_e) {
88372         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88373         return ;
88374       }
88375
88376     } catch (std::out_of_range& e) {
88377       {
88378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88379       };
88380     } catch (std::exception& e) {
88381       {
88382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88383       };
88384     } catch (...) {
88385       {
88386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88387       };
88388     }
88389   }
88390 }
88391
88392
88393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88394   void * jresult ;
88395   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88396   int arg2 ;
88397   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88398
88399   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88400   if (!arg1) {
88401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88402     return 0;
88403   }
88404   arg2 = (int)jarg2;
88405   {
88406     try {
88407       try {
88408         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);
88409       }
88410       catch(std::out_of_range &_e) {
88411         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88412         return 0;
88413       }
88414
88415     } catch (std::out_of_range& e) {
88416       {
88417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88418       };
88419     } catch (std::exception& e) {
88420       {
88421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88422       };
88423     } catch (...) {
88424       {
88425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88426       };
88427     }
88428   }
88429   jresult = (void *)result;
88430   return jresult;
88431 }
88432
88433
88434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88435   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88436
88437   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88438   {
88439     try {
88440       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88441     } catch (std::out_of_range& e) {
88442       {
88443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88444       };
88445     } catch (std::exception& e) {
88446       {
88447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88448       };
88449     } catch (...) {
88450       {
88451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88452       };
88453     }
88454   }
88455 }
88456
88457
88458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88459   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88460   int arg2 ;
88461   int arg3 ;
88462
88463   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88464   arg2 = (int)jarg2;
88465   arg3 = (int)jarg3;
88466   {
88467     try {
88468       try {
88469         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88470       }
88471       catch(std::out_of_range &_e) {
88472         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88473         return ;
88474       }
88475       catch(std::invalid_argument &_e) {
88476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88477         return ;
88478       }
88479
88480     } catch (std::out_of_range& e) {
88481       {
88482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88483       };
88484     } catch (std::exception& e) {
88485       {
88486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88487       };
88488     } catch (...) {
88489       {
88490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88491       };
88492     }
88493   }
88494 }
88495
88496
88497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88498   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88499   int arg2 ;
88500   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88501
88502   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88503   arg2 = (int)jarg2;
88504   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88505   if (!arg3) {
88506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88507     return ;
88508   }
88509   {
88510     try {
88511       try {
88512         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);
88513       }
88514       catch(std::out_of_range &_e) {
88515         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88516         return ;
88517       }
88518
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88526       };
88527     } catch (...) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88530       };
88531     }
88532   }
88533 }
88534
88535
88536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88537   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88538
88539   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88540   {
88541     try {
88542       delete arg1;
88543     } catch (std::out_of_range& e) {
88544       {
88545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88546       };
88547     } catch (std::exception& e) {
88548       {
88549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88550       };
88551     } catch (...) {
88552       {
88553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88554       };
88555     }
88556   }
88557 }
88558
88559
88560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88561   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88562
88563   arg1 = (std::vector< Dali::Actor > *)jarg1;
88564   {
88565     try {
88566       (arg1)->clear();
88567     } catch (std::out_of_range& e) {
88568       {
88569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88570       };
88571     } catch (std::exception& e) {
88572       {
88573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88574       };
88575     } catch (...) {
88576       {
88577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88578       };
88579     }
88580   }
88581 }
88582
88583
88584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88585   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88586   Dali::Actor *arg2 = 0 ;
88587
88588   arg1 = (std::vector< Dali::Actor > *)jarg1;
88589   arg2 = (Dali::Actor *)jarg2;
88590   if (!arg2) {
88591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88592     return ;
88593   }
88594   {
88595     try {
88596       (arg1)->push_back((Dali::Actor const &)*arg2);
88597     } catch (std::out_of_range& e) {
88598       {
88599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88600       };
88601     } catch (std::exception& e) {
88602       {
88603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88604       };
88605     } catch (...) {
88606       {
88607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88608       };
88609     }
88610   }
88611 }
88612
88613
88614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88615   unsigned long jresult ;
88616   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88617   std::vector< Dali::Actor >::size_type result;
88618
88619   arg1 = (std::vector< Dali::Actor > *)jarg1;
88620   {
88621     try {
88622       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88623     } catch (std::out_of_range& e) {
88624       {
88625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88626       };
88627     } catch (std::exception& e) {
88628       {
88629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88630       };
88631     } catch (...) {
88632       {
88633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88634       };
88635     }
88636   }
88637   jresult = (unsigned long)result;
88638   return jresult;
88639 }
88640
88641
88642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88643   unsigned long jresult ;
88644   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88645   std::vector< Dali::Actor >::size_type result;
88646
88647   arg1 = (std::vector< Dali::Actor > *)jarg1;
88648   {
88649     try {
88650       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88651     } catch (std::out_of_range& e) {
88652       {
88653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88654       };
88655     } catch (std::exception& e) {
88656       {
88657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88658       };
88659     } catch (...) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88662       };
88663     }
88664   }
88665   jresult = (unsigned long)result;
88666   return jresult;
88667 }
88668
88669
88670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88671   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88672   std::vector< Dali::Actor >::size_type arg2 ;
88673
88674   arg1 = (std::vector< Dali::Actor > *)jarg1;
88675   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88676   {
88677     try {
88678       (arg1)->reserve(arg2);
88679     } catch (std::out_of_range& e) {
88680       {
88681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88682       };
88683     } catch (std::exception& e) {
88684       {
88685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88686       };
88687     } catch (...) {
88688       {
88689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88690       };
88691     }
88692   }
88693 }
88694
88695
88696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88697   void * jresult ;
88698   std::vector< Dali::Actor > *result = 0 ;
88699
88700   {
88701     try {
88702       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88703     } catch (std::out_of_range& e) {
88704       {
88705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88706       };
88707     } catch (std::exception& e) {
88708       {
88709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88710       };
88711     } catch (...) {
88712       {
88713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88714       };
88715     }
88716   }
88717   jresult = (void *)result;
88718   return jresult;
88719 }
88720
88721
88722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88723   void * jresult ;
88724   std::vector< Dali::Actor > *arg1 = 0 ;
88725   std::vector< Dali::Actor > *result = 0 ;
88726
88727   arg1 = (std::vector< Dali::Actor > *)jarg1;
88728   if (!arg1) {
88729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88730     return 0;
88731   }
88732   {
88733     try {
88734       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88735     } catch (std::out_of_range& e) {
88736       {
88737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88738       };
88739     } catch (std::exception& e) {
88740       {
88741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88742       };
88743     } catch (...) {
88744       {
88745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88746       };
88747     }
88748   }
88749   jresult = (void *)result;
88750   return jresult;
88751 }
88752
88753
88754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88755   void * jresult ;
88756   int arg1 ;
88757   std::vector< Dali::Actor > *result = 0 ;
88758
88759   arg1 = (int)jarg1;
88760   {
88761     try {
88762       try {
88763         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88764       }
88765       catch(std::out_of_range &_e) {
88766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88767         return 0;
88768       }
88769
88770     } catch (std::out_of_range& e) {
88771       {
88772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88773       };
88774     } catch (std::exception& e) {
88775       {
88776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88777       };
88778     } catch (...) {
88779       {
88780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88781       };
88782     }
88783   }
88784   jresult = (void *)result;
88785   return jresult;
88786 }
88787
88788
88789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88790   void * jresult ;
88791   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88792   int arg2 ;
88793   Dali::Actor result;
88794
88795   arg1 = (std::vector< Dali::Actor > *)jarg1;
88796   arg2 = (int)jarg2;
88797   {
88798     try {
88799       try {
88800         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88801       }
88802       catch(std::out_of_range &_e) {
88803         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88804         return 0;
88805       }
88806
88807     } catch (std::out_of_range& e) {
88808       {
88809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88810       };
88811     } catch (std::exception& e) {
88812       {
88813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88814       };
88815     } catch (...) {
88816       {
88817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88818       };
88819     }
88820   }
88821   jresult = new Dali::Actor((const Dali::Actor &)result);
88822   return jresult;
88823 }
88824
88825
88826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88827   void * jresult ;
88828   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88829   int arg2 ;
88830   Dali::Actor *result = 0 ;
88831
88832   arg1 = (std::vector< Dali::Actor > *)jarg1;
88833   arg2 = (int)jarg2;
88834   {
88835     try {
88836       try {
88837         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88838       }
88839       catch(std::out_of_range &_e) {
88840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88841         return 0;
88842       }
88843
88844     } catch (std::out_of_range& e) {
88845       {
88846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88847       };
88848     } catch (std::exception& e) {
88849       {
88850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88851       };
88852     } catch (...) {
88853       {
88854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88855       };
88856     }
88857   }
88858   jresult = (void *)result;
88859   return jresult;
88860 }
88861
88862
88863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88864   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88865   int arg2 ;
88866   Dali::Actor *arg3 = 0 ;
88867
88868   arg1 = (std::vector< Dali::Actor > *)jarg1;
88869   arg2 = (int)jarg2;
88870   arg3 = (Dali::Actor *)jarg3;
88871   if (!arg3) {
88872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88873     return ;
88874   }
88875   {
88876     try {
88877       try {
88878         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88879       }
88880       catch(std::out_of_range &_e) {
88881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88882         return ;
88883       }
88884
88885     } catch (std::out_of_range& e) {
88886       {
88887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88888       };
88889     } catch (std::exception& e) {
88890       {
88891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88892       };
88893     } catch (...) {
88894       {
88895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88896       };
88897     }
88898   }
88899 }
88900
88901
88902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88903   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88904   std::vector< Dali::Actor > *arg2 = 0 ;
88905
88906   arg1 = (std::vector< Dali::Actor > *)jarg1;
88907   arg2 = (std::vector< Dali::Actor > *)jarg2;
88908   if (!arg2) {
88909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88910     return ;
88911   }
88912   {
88913     try {
88914       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88915     } catch (std::out_of_range& e) {
88916       {
88917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88918       };
88919     } catch (std::exception& e) {
88920       {
88921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88922       };
88923     } catch (...) {
88924       {
88925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88926       };
88927     }
88928   }
88929 }
88930
88931
88932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88933   void * jresult ;
88934   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88935   int arg2 ;
88936   int arg3 ;
88937   std::vector< Dali::Actor > *result = 0 ;
88938
88939   arg1 = (std::vector< Dali::Actor > *)jarg1;
88940   arg2 = (int)jarg2;
88941   arg3 = (int)jarg3;
88942   {
88943     try {
88944       try {
88945         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88946       }
88947       catch(std::out_of_range &_e) {
88948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88949         return 0;
88950       }
88951       catch(std::invalid_argument &_e) {
88952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88953         return 0;
88954       }
88955
88956     } catch (std::out_of_range& e) {
88957       {
88958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88959       };
88960     } catch (std::exception& e) {
88961       {
88962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88963       };
88964     } catch (...) {
88965       {
88966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88967       };
88968     }
88969   }
88970   jresult = (void *)result;
88971   return jresult;
88972 }
88973
88974
88975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88976   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88977   int arg2 ;
88978   Dali::Actor *arg3 = 0 ;
88979
88980   arg1 = (std::vector< Dali::Actor > *)jarg1;
88981   arg2 = (int)jarg2;
88982   arg3 = (Dali::Actor *)jarg3;
88983   if (!arg3) {
88984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88985     return ;
88986   }
88987   {
88988     try {
88989       try {
88990         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88991       }
88992       catch(std::out_of_range &_e) {
88993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88994         return ;
88995       }
88996
88997     } catch (std::out_of_range& e) {
88998       {
88999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89000       };
89001     } catch (std::exception& e) {
89002       {
89003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89004       };
89005     } catch (...) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89008       };
89009     }
89010   }
89011 }
89012
89013
89014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89015   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89016   int arg2 ;
89017   std::vector< Dali::Actor > *arg3 = 0 ;
89018
89019   arg1 = (std::vector< Dali::Actor > *)jarg1;
89020   arg2 = (int)jarg2;
89021   arg3 = (std::vector< Dali::Actor > *)jarg3;
89022   if (!arg3) {
89023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89024     return ;
89025   }
89026   {
89027     try {
89028       try {
89029         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89030       }
89031       catch(std::out_of_range &_e) {
89032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89033         return ;
89034       }
89035
89036     } catch (std::out_of_range& e) {
89037       {
89038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89039       };
89040     } catch (std::exception& e) {
89041       {
89042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89043       };
89044     } catch (...) {
89045       {
89046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89047       };
89048     }
89049   }
89050 }
89051
89052
89053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89054   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89055   int arg2 ;
89056
89057   arg1 = (std::vector< Dali::Actor > *)jarg1;
89058   arg2 = (int)jarg2;
89059   {
89060     try {
89061       try {
89062         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89063       }
89064       catch(std::out_of_range &_e) {
89065         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89066         return ;
89067       }
89068
89069     } catch (std::out_of_range& e) {
89070       {
89071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89072       };
89073     } catch (std::exception& e) {
89074       {
89075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89076       };
89077     } catch (...) {
89078       {
89079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89080       };
89081     }
89082   }
89083 }
89084
89085
89086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89087   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89088   int arg2 ;
89089   int arg3 ;
89090
89091   arg1 = (std::vector< Dali::Actor > *)jarg1;
89092   arg2 = (int)jarg2;
89093   arg3 = (int)jarg3;
89094   {
89095     try {
89096       try {
89097         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89098       }
89099       catch(std::out_of_range &_e) {
89100         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89101         return ;
89102       }
89103       catch(std::invalid_argument &_e) {
89104         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89105         return ;
89106       }
89107
89108     } catch (std::out_of_range& e) {
89109       {
89110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89111       };
89112     } catch (std::exception& e) {
89113       {
89114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89115       };
89116     } catch (...) {
89117       {
89118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89119       };
89120     }
89121   }
89122 }
89123
89124
89125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89126   void * jresult ;
89127   Dali::Actor *arg1 = 0 ;
89128   int arg2 ;
89129   std::vector< Dali::Actor > *result = 0 ;
89130
89131   arg1 = (Dali::Actor *)jarg1;
89132   if (!arg1) {
89133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89134     return 0;
89135   }
89136   arg2 = (int)jarg2;
89137   {
89138     try {
89139       try {
89140         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89141       }
89142       catch(std::out_of_range &_e) {
89143         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89144         return 0;
89145       }
89146
89147     } catch (std::out_of_range& e) {
89148       {
89149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89150       };
89151     } catch (std::exception& e) {
89152       {
89153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89154       };
89155     } catch (...) {
89156       {
89157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89158       };
89159     }
89160   }
89161   jresult = (void *)result;
89162   return jresult;
89163 }
89164
89165
89166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89167   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89168
89169   arg1 = (std::vector< Dali::Actor > *)jarg1;
89170   {
89171     try {
89172       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89173     } catch (std::out_of_range& e) {
89174       {
89175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89176       };
89177     } catch (std::exception& e) {
89178       {
89179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89180       };
89181     } catch (...) {
89182       {
89183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89184       };
89185     }
89186   }
89187 }
89188
89189
89190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89191   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89192   int arg2 ;
89193   int arg3 ;
89194
89195   arg1 = (std::vector< Dali::Actor > *)jarg1;
89196   arg2 = (int)jarg2;
89197   arg3 = (int)jarg3;
89198   {
89199     try {
89200       try {
89201         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89202       }
89203       catch(std::out_of_range &_e) {
89204         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89205         return ;
89206       }
89207       catch(std::invalid_argument &_e) {
89208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89209         return ;
89210       }
89211
89212     } catch (std::out_of_range& e) {
89213       {
89214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89215       };
89216     } catch (std::exception& e) {
89217       {
89218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89219       };
89220     } catch (...) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89223       };
89224     }
89225   }
89226 }
89227
89228
89229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89230   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89231   int arg2 ;
89232   std::vector< Dali::Actor > *arg3 = 0 ;
89233
89234   arg1 = (std::vector< Dali::Actor > *)jarg1;
89235   arg2 = (int)jarg2;
89236   arg3 = (std::vector< Dali::Actor > *)jarg3;
89237   if (!arg3) {
89238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89239     return ;
89240   }
89241   {
89242     try {
89243       try {
89244         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89245       }
89246       catch(std::out_of_range &_e) {
89247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89248         return ;
89249       }
89250
89251     } catch (std::out_of_range& e) {
89252       {
89253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89254       };
89255     } catch (std::exception& e) {
89256       {
89257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89258       };
89259     } catch (...) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89262       };
89263     }
89264   }
89265 }
89266
89267
89268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89269   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89270
89271   arg1 = (std::vector< Dali::Actor > *)jarg1;
89272   {
89273     try {
89274       delete arg1;
89275     } catch (std::out_of_range& e) {
89276       {
89277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89278       };
89279     } catch (std::exception& e) {
89280       {
89281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89282       };
89283     } catch (...) {
89284       {
89285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89286       };
89287     }
89288   }
89289 }
89290
89291
89292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89293   unsigned int jresult ;
89294   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89295   bool result;
89296
89297   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89298   {
89299     try {
89300       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89301     } catch (std::out_of_range& e) {
89302       {
89303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89304       };
89305     } catch (std::exception& e) {
89306       {
89307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89308       };
89309     } catch (...) {
89310       {
89311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89312       };
89313     }
89314   }
89315   jresult = result;
89316   return jresult;
89317 }
89318
89319
89320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89321   unsigned long jresult ;
89322   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89323   std::size_t result;
89324
89325   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89326   {
89327     try {
89328       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89329     } catch (std::out_of_range& e) {
89330       {
89331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89332       };
89333     } catch (std::exception& e) {
89334       {
89335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89336       };
89337     } catch (...) {
89338       {
89339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89340       };
89341     }
89342   }
89343   jresult = (unsigned long)result;
89344   return jresult;
89345 }
89346
89347
89348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89349   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89350   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89351
89352   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89353   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89354   {
89355     try {
89356       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89357     } catch (std::out_of_range& e) {
89358       {
89359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89360       };
89361     } catch (std::exception& e) {
89362       {
89363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89364       };
89365     } catch (...) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89368       };
89369     }
89370   }
89371 }
89372
89373
89374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89375   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89376   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89377
89378   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89379   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89380   {
89381     try {
89382       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89383     } catch (std::out_of_range& e) {
89384       {
89385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89386       };
89387     } catch (std::exception& e) {
89388       {
89389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89390       };
89391     } catch (...) {
89392       {
89393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89394       };
89395     }
89396   }
89397 }
89398
89399
89400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89401   unsigned int jresult ;
89402   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89403   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89404   bool result;
89405
89406   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89407   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89408   if (!arg2) {
89409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89410     return 0;
89411   }
89412   {
89413     try {
89414       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89415     } catch (std::out_of_range& e) {
89416       {
89417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89418       };
89419     } catch (std::exception& e) {
89420       {
89421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89422       };
89423     } catch (...) {
89424       {
89425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89426       };
89427     }
89428   }
89429   jresult = result;
89430   return jresult;
89431 }
89432
89433
89434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89435   void * jresult ;
89436   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89437
89438   {
89439     try {
89440       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89441     } catch (std::out_of_range& e) {
89442       {
89443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89444       };
89445     } catch (std::exception& e) {
89446       {
89447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89448       };
89449     } catch (...) {
89450       {
89451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89452       };
89453     }
89454   }
89455   jresult = (void *)result;
89456   return jresult;
89457 }
89458
89459
89460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89461   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89462
89463   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89464   {
89465     try {
89466       delete arg1;
89467     } catch (std::out_of_range& e) {
89468       {
89469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89470       };
89471     } catch (std::exception& e) {
89472       {
89473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89474       };
89475     } catch (...) {
89476       {
89477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89478       };
89479     }
89480   }
89481 }
89482
89483
89484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89485   unsigned int jresult ;
89486   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89487   bool result;
89488
89489   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89490   {
89491     try {
89492       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);
89493     } catch (std::out_of_range& e) {
89494       {
89495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89496       };
89497     } catch (std::exception& e) {
89498       {
89499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89500       };
89501     } catch (...) {
89502       {
89503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89504       };
89505     }
89506   }
89507   jresult = result;
89508   return jresult;
89509 }
89510
89511
89512 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89513   unsigned long jresult ;
89514   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89515   std::size_t result;
89516
89517   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89518   {
89519     try {
89520       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);
89521     } catch (std::out_of_range& e) {
89522       {
89523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89524       };
89525     } catch (std::exception& e) {
89526       {
89527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89528       };
89529     } catch (...) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89532       };
89533     }
89534   }
89535   jresult = (unsigned long)result;
89536   return jresult;
89537 }
89538
89539
89540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89541   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89542   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89543
89544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89545   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89546   {
89547     try {
89548       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89549     } catch (std::out_of_range& e) {
89550       {
89551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89552       };
89553     } catch (std::exception& e) {
89554       {
89555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89556       };
89557     } catch (...) {
89558       {
89559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89560       };
89561     }
89562   }
89563 }
89564
89565
89566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89567   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89568   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89569
89570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89571   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89572   {
89573     try {
89574       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89575     } catch (std::out_of_range& e) {
89576       {
89577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89578       };
89579     } catch (std::exception& e) {
89580       {
89581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89582       };
89583     } catch (...) {
89584       {
89585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89586       };
89587     }
89588   }
89589 }
89590
89591
89592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89593   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89594   Dali::Actor arg2 ;
89595   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89596   Dali::Actor *argp2 ;
89597
89598   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89599   argp2 = (Dali::Actor *)jarg2;
89600   if (!argp2) {
89601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89602     return ;
89603   }
89604   arg2 = *argp2;
89605   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89606   {
89607     try {
89608       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89609     } catch (std::out_of_range& e) {
89610       {
89611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89612       };
89613     } catch (std::exception& e) {
89614       {
89615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89616       };
89617     } catch (...) {
89618       {
89619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89620       };
89621     }
89622   }
89623 }
89624
89625
89626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89627   void * jresult ;
89628   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89629
89630   {
89631     try {
89632       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89633     } catch (std::out_of_range& e) {
89634       {
89635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89636       };
89637     } catch (std::exception& e) {
89638       {
89639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (...) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89644       };
89645     }
89646   }
89647   jresult = (void *)result;
89648   return jresult;
89649 }
89650
89651
89652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89653   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89654
89655   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89656   {
89657     try {
89658       delete arg1;
89659     } catch (std::out_of_range& e) {
89660       {
89661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89662       };
89663     } catch (std::exception& e) {
89664       {
89665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89666       };
89667     } catch (...) {
89668       {
89669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89670       };
89671     }
89672   }
89673 }
89674
89675
89676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89677   unsigned int jresult ;
89678   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89679   bool result;
89680
89681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89682   {
89683     try {
89684       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89685     } catch (std::out_of_range& e) {
89686       {
89687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89688       };
89689     } catch (std::exception& e) {
89690       {
89691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89692       };
89693     } catch (...) {
89694       {
89695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89696       };
89697     }
89698   }
89699   jresult = result;
89700   return jresult;
89701 }
89702
89703
89704 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89705   unsigned long jresult ;
89706   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89707   std::size_t result;
89708
89709   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89710   {
89711     try {
89712       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89713     } catch (std::out_of_range& e) {
89714       {
89715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89716       };
89717     } catch (std::exception& e) {
89718       {
89719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89720       };
89721     } catch (...) {
89722       {
89723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89724       };
89725     }
89726   }
89727   jresult = (unsigned long)result;
89728   return jresult;
89729 }
89730
89731
89732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89733   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89734   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89735
89736   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89737   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89738   {
89739     try {
89740       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89741     } catch (std::out_of_range& e) {
89742       {
89743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89744       };
89745     } catch (std::exception& e) {
89746       {
89747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89748       };
89749     } catch (...) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89752       };
89753     }
89754   }
89755 }
89756
89757
89758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89759   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89760   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89761
89762   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89763   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89764   {
89765     try {
89766       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89774       };
89775     } catch (...) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89778       };
89779     }
89780   }
89781 }
89782
89783
89784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89785   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89786   Dali::Actor arg2 ;
89787   Dali::Actor arg3 ;
89788   Dali::Actor *argp2 ;
89789   Dali::Actor *argp3 ;
89790
89791   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89792   argp2 = (Dali::Actor *)jarg2;
89793   if (!argp2) {
89794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89795     return ;
89796   }
89797   arg2 = *argp2;
89798   argp3 = (Dali::Actor *)jarg3;
89799   if (!argp3) {
89800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89801     return ;
89802   }
89803   arg3 = *argp3;
89804   {
89805     try {
89806       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89807     } catch (std::out_of_range& e) {
89808       {
89809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89810       };
89811     } catch (std::exception& e) {
89812       {
89813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89814       };
89815     } catch (...) {
89816       {
89817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89818       };
89819     }
89820   }
89821 }
89822
89823
89824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89825   void * jresult ;
89826   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89827
89828   {
89829     try {
89830       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89831     } catch (std::out_of_range& e) {
89832       {
89833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89834       };
89835     } catch (std::exception& e) {
89836       {
89837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89838       };
89839     } catch (...) {
89840       {
89841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89842       };
89843     }
89844   }
89845   jresult = (void *)result;
89846   return jresult;
89847 }
89848
89849
89850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89851   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89852
89853   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89854   {
89855     try {
89856       delete arg1;
89857     } catch (std::out_of_range& e) {
89858       {
89859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89860       };
89861     } catch (std::exception& e) {
89862       {
89863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89864       };
89865     } catch (...) {
89866       {
89867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89868       };
89869     }
89870   }
89871 }
89872
89873
89874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89875   unsigned int jresult ;
89876   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89877   bool result;
89878
89879   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89880   {
89881     try {
89882       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89883     } catch (std::out_of_range& e) {
89884       {
89885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89886       };
89887     } catch (std::exception& e) {
89888       {
89889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89890       };
89891     } catch (...) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89894       };
89895     }
89896   }
89897   jresult = result;
89898   return jresult;
89899 }
89900
89901
89902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89903   unsigned long jresult ;
89904   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89905   std::size_t result;
89906
89907   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89908   {
89909     try {
89910       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89911     } catch (std::out_of_range& e) {
89912       {
89913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89914       };
89915     } catch (std::exception& e) {
89916       {
89917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89918       };
89919     } catch (...) {
89920       {
89921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89922       };
89923     }
89924   }
89925   jresult = (unsigned long)result;
89926   return jresult;
89927 }
89928
89929
89930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89931   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89932   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89933
89934   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89935   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89936   {
89937     try {
89938       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89939     } catch (std::out_of_range& e) {
89940       {
89941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89942       };
89943     } catch (std::exception& e) {
89944       {
89945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89946       };
89947     } catch (...) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89950       };
89951     }
89952   }
89953 }
89954
89955
89956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89957   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89958   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89959
89960   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89961   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89962   {
89963     try {
89964       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89965     } catch (std::out_of_range& e) {
89966       {
89967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89968       };
89969     } catch (std::exception& e) {
89970       {
89971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89972       };
89973     } catch (...) {
89974       {
89975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89976       };
89977     }
89978   }
89979 }
89980
89981
89982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89983   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89984   Dali::Actor arg2 ;
89985   bool arg3 ;
89986   Dali::Actor *argp2 ;
89987
89988   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89989   argp2 = (Dali::Actor *)jarg2;
89990   if (!argp2) {
89991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89992     return ;
89993   }
89994   arg2 = *argp2;
89995   arg3 = jarg3 ? true : false;
89996   {
89997     try {
89998       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89999     } catch (std::out_of_range& e) {
90000       {
90001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90002       };
90003     } catch (std::exception& e) {
90004       {
90005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90006       };
90007     } catch (...) {
90008       {
90009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90010       };
90011     }
90012   }
90013 }
90014
90015
90016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90017   void * jresult ;
90018   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90019
90020   {
90021     try {
90022       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90023     } catch (std::out_of_range& e) {
90024       {
90025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90026       };
90027     } catch (std::exception& e) {
90028       {
90029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90030       };
90031     } catch (...) {
90032       {
90033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90034       };
90035     }
90036   }
90037   jresult = (void *)result;
90038   return jresult;
90039 }
90040
90041
90042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90043   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90044
90045   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90046   {
90047     try {
90048       delete arg1;
90049     } catch (std::out_of_range& e) {
90050       {
90051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90052       };
90053     } catch (std::exception& e) {
90054       {
90055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90056       };
90057     } catch (...) {
90058       {
90059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90060       };
90061     }
90062   }
90063 }
90064
90065
90066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90067   unsigned int jresult ;
90068   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90069   bool result;
90070
90071   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90072   {
90073     try {
90074       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);
90075     } catch (std::out_of_range& e) {
90076       {
90077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90078       };
90079     } catch (std::exception& e) {
90080       {
90081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90082       };
90083     } catch (...) {
90084       {
90085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90086       };
90087     }
90088   }
90089   jresult = result;
90090   return jresult;
90091 }
90092
90093
90094 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90095   unsigned long jresult ;
90096   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90097   std::size_t result;
90098
90099   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90100   {
90101     try {
90102       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);
90103     } catch (std::out_of_range& e) {
90104       {
90105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90106       };
90107     } catch (std::exception& e) {
90108       {
90109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90110       };
90111     } catch (...) {
90112       {
90113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90114       };
90115     }
90116   }
90117   jresult = (unsigned long)result;
90118   return jresult;
90119 }
90120
90121
90122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90123   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90124   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90125
90126   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90127   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90128   {
90129     try {
90130       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90131     } catch (std::out_of_range& e) {
90132       {
90133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90134       };
90135     } catch (std::exception& e) {
90136       {
90137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90138       };
90139     } catch (...) {
90140       {
90141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90142       };
90143     }
90144   }
90145 }
90146
90147
90148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90149   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90150   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90151
90152   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90153   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90154   {
90155     try {
90156       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90157     } catch (std::out_of_range& e) {
90158       {
90159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90160       };
90161     } catch (std::exception& e) {
90162       {
90163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90164       };
90165     } catch (...) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90168       };
90169     }
90170   }
90171 }
90172
90173
90174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90175   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90176   Dali::Toolkit::StyleManager arg2 ;
90177   Dali::StyleChange::Type arg3 ;
90178   Dali::Toolkit::StyleManager *argp2 ;
90179
90180   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90181   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90182   if (!argp2) {
90183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90184     return ;
90185   }
90186   arg2 = *argp2;
90187   arg3 = (Dali::StyleChange::Type)jarg3;
90188   {
90189     try {
90190       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90191     } catch (std::out_of_range& e) {
90192       {
90193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90194       };
90195     } catch (std::exception& e) {
90196       {
90197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90198       };
90199     } catch (...) {
90200       {
90201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90202       };
90203     }
90204   }
90205 }
90206
90207
90208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90209   void * jresult ;
90210   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90211
90212   {
90213     try {
90214       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90215     } catch (std::out_of_range& e) {
90216       {
90217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90218       };
90219     } catch (std::exception& e) {
90220       {
90221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90222       };
90223     } catch (...) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90226       };
90227     }
90228   }
90229   jresult = (void *)result;
90230   return jresult;
90231 }
90232
90233
90234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90235   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90236
90237   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90238   {
90239     try {
90240       delete arg1;
90241     } catch (std::out_of_range& e) {
90242       {
90243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90244       };
90245     } catch (std::exception& e) {
90246       {
90247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90248       };
90249     } catch (...) {
90250       {
90251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90252       };
90253     }
90254   }
90255 }
90256
90257
90258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90259   unsigned int jresult ;
90260   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90261   bool result;
90262
90263   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90264   {
90265     try {
90266       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90267     } catch (std::out_of_range& e) {
90268       {
90269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90270       };
90271     } catch (std::exception& e) {
90272       {
90273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90274       };
90275     } catch (...) {
90276       {
90277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90278       };
90279     }
90280   }
90281   jresult = result;
90282   return jresult;
90283 }
90284
90285
90286 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90287   unsigned long jresult ;
90288   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90289   std::size_t result;
90290
90291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90292   {
90293     try {
90294       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90295     } catch (std::out_of_range& e) {
90296       {
90297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90298       };
90299     } catch (std::exception& e) {
90300       {
90301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90302       };
90303     } catch (...) {
90304       {
90305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90306       };
90307     }
90308   }
90309   jresult = (unsigned long)result;
90310   return jresult;
90311 }
90312
90313
90314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90315   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90316   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90317
90318   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90319   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90320   {
90321     try {
90322       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90323     } catch (std::out_of_range& e) {
90324       {
90325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90326       };
90327     } catch (std::exception& e) {
90328       {
90329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90330       };
90331     } catch (...) {
90332       {
90333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90334       };
90335     }
90336   }
90337 }
90338
90339
90340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90341   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90342   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90343
90344   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90345   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90346   {
90347     try {
90348       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90349     } catch (std::out_of_range& e) {
90350       {
90351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90352       };
90353     } catch (std::exception& e) {
90354       {
90355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90356       };
90357     } catch (...) {
90358       {
90359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90360       };
90361     }
90362   }
90363 }
90364
90365
90366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90367   unsigned int jresult ;
90368   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90369   Dali::Toolkit::Button arg2 ;
90370   Dali::Toolkit::Button *argp2 ;
90371   bool result;
90372
90373   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90374   argp2 = (Dali::Toolkit::Button *)jarg2;
90375   if (!argp2) {
90376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90377     return 0;
90378   }
90379   arg2 = *argp2;
90380   {
90381     try {
90382       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90383     } catch (std::out_of_range& e) {
90384       {
90385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90386       };
90387     } catch (std::exception& e) {
90388       {
90389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90390       };
90391     } catch (...) {
90392       {
90393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90394       };
90395     }
90396   }
90397   jresult = result;
90398   return jresult;
90399 }
90400
90401
90402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90403   void * jresult ;
90404   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90405
90406   {
90407     try {
90408       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90409     } catch (std::out_of_range& e) {
90410       {
90411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90412       };
90413     } catch (std::exception& e) {
90414       {
90415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90416       };
90417     } catch (...) {
90418       {
90419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90420       };
90421     }
90422   }
90423   jresult = (void *)result;
90424   return jresult;
90425 }
90426
90427
90428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90429   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90430
90431   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90432   {
90433     try {
90434       delete arg1;
90435     } catch (std::out_of_range& e) {
90436       {
90437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90438       };
90439     } catch (std::exception& e) {
90440       {
90441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90442       };
90443     } catch (...) {
90444       {
90445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90446       };
90447     }
90448   }
90449 }
90450
90451
90452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90453   unsigned int jresult ;
90454   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90455   bool result;
90456
90457   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90458   {
90459     try {
90460       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90461     } catch (std::out_of_range& e) {
90462       {
90463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90464       };
90465     } catch (std::exception& e) {
90466       {
90467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90468       };
90469     } catch (...) {
90470       {
90471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90472       };
90473     }
90474   }
90475   jresult = result;
90476   return jresult;
90477 }
90478
90479
90480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90481   unsigned long jresult ;
90482   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90483   std::size_t result;
90484
90485   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90486   {
90487     try {
90488       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90489     } catch (std::out_of_range& e) {
90490       {
90491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90492       };
90493     } catch (std::exception& e) {
90494       {
90495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90496       };
90497     } catch (...) {
90498       {
90499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90500       };
90501     }
90502   }
90503   jresult = (unsigned long)result;
90504   return jresult;
90505 }
90506
90507
90508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90509   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90510   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90511
90512   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90513   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90514   {
90515     try {
90516       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90517     } catch (std::out_of_range& e) {
90518       {
90519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90520       };
90521     } catch (std::exception& e) {
90522       {
90523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90524       };
90525     } catch (...) {
90526       {
90527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90528       };
90529     }
90530   }
90531 }
90532
90533
90534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90535   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90536   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90537
90538   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90539   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90540   {
90541     try {
90542       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90543     } catch (std::out_of_range& e) {
90544       {
90545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90546       };
90547     } catch (std::exception& e) {
90548       {
90549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90550       };
90551     } catch (...) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90554       };
90555     }
90556   }
90557 }
90558
90559
90560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90561   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90562   Dali::Toolkit::GaussianBlurView arg2 ;
90563   Dali::Toolkit::GaussianBlurView *argp2 ;
90564
90565   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90566   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90567   if (!argp2) {
90568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90569     return ;
90570   }
90571   arg2 = *argp2;
90572   {
90573     try {
90574       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90582       };
90583     } catch (...) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90586       };
90587     }
90588   }
90589 }
90590
90591
90592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90593   void * jresult ;
90594   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90595
90596   {
90597     try {
90598       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90599     } catch (std::out_of_range& e) {
90600       {
90601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90602       };
90603     } catch (std::exception& e) {
90604       {
90605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90606       };
90607     } catch (...) {
90608       {
90609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90610       };
90611     }
90612   }
90613   jresult = (void *)result;
90614   return jresult;
90615 }
90616
90617
90618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90619   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90620
90621   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90622   {
90623     try {
90624       delete arg1;
90625     } catch (std::out_of_range& e) {
90626       {
90627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90628       };
90629     } catch (std::exception& e) {
90630       {
90631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90632       };
90633     } catch (...) {
90634       {
90635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90636       };
90637     }
90638   }
90639 }
90640
90641
90642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90643   unsigned int jresult ;
90644   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90645   bool result;
90646
90647   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90648   {
90649     try {
90650       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);
90651     } catch (std::out_of_range& e) {
90652       {
90653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (std::exception& e) {
90656       {
90657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (...) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90662       };
90663     }
90664   }
90665   jresult = result;
90666   return jresult;
90667 }
90668
90669
90670 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90671   unsigned long jresult ;
90672   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90673   std::size_t result;
90674
90675   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90676   {
90677     try {
90678       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);
90679     } catch (std::out_of_range& e) {
90680       {
90681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90682       };
90683     } catch (std::exception& e) {
90684       {
90685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90686       };
90687     } catch (...) {
90688       {
90689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90690       };
90691     }
90692   }
90693   jresult = (unsigned long)result;
90694   return jresult;
90695 }
90696
90697
90698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90699   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90700   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90701
90702   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90703   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90704   {
90705     try {
90706       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90707     } catch (std::out_of_range& e) {
90708       {
90709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90710       };
90711     } catch (std::exception& e) {
90712       {
90713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90714       };
90715     } catch (...) {
90716       {
90717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90718       };
90719     }
90720   }
90721 }
90722
90723
90724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90725   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90726   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90727
90728   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90729   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90730   {
90731     try {
90732       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90733     } catch (std::out_of_range& e) {
90734       {
90735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90736       };
90737     } catch (std::exception& e) {
90738       {
90739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90740       };
90741     } catch (...) {
90742       {
90743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90744       };
90745     }
90746   }
90747 }
90748
90749
90750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90751   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90752   Dali::Toolkit::PageTurnView arg2 ;
90753   unsigned int arg3 ;
90754   bool arg4 ;
90755   Dali::Toolkit::PageTurnView *argp2 ;
90756
90757   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90758   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90759   if (!argp2) {
90760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90761     return ;
90762   }
90763   arg2 = *argp2;
90764   arg3 = (unsigned int)jarg3;
90765   arg4 = jarg4 ? true : false;
90766   {
90767     try {
90768       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90769     } catch (std::out_of_range& e) {
90770       {
90771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90772       };
90773     } catch (std::exception& e) {
90774       {
90775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90776       };
90777     } catch (...) {
90778       {
90779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90780       };
90781     }
90782   }
90783 }
90784
90785
90786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90787   void * jresult ;
90788   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90789
90790   {
90791     try {
90792       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90793     } catch (std::out_of_range& e) {
90794       {
90795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90796       };
90797     } catch (std::exception& e) {
90798       {
90799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90800       };
90801     } catch (...) {
90802       {
90803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90804       };
90805     }
90806   }
90807   jresult = (void *)result;
90808   return jresult;
90809 }
90810
90811
90812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90813   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90814
90815   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90816   {
90817     try {
90818       delete arg1;
90819     } catch (std::out_of_range& e) {
90820       {
90821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90822       };
90823     } catch (std::exception& e) {
90824       {
90825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90826       };
90827     } catch (...) {
90828       {
90829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90830       };
90831     }
90832   }
90833 }
90834
90835
90836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90837   unsigned int jresult ;
90838   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90839   bool result;
90840
90841   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90842   {
90843     try {
90844       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90845     } catch (std::out_of_range& e) {
90846       {
90847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90848       };
90849     } catch (std::exception& e) {
90850       {
90851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90852       };
90853     } catch (...) {
90854       {
90855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90856       };
90857     }
90858   }
90859   jresult = result;
90860   return jresult;
90861 }
90862
90863
90864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90865   unsigned long jresult ;
90866   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90867   std::size_t result;
90868
90869   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90870   {
90871     try {
90872       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90873     } catch (std::out_of_range& e) {
90874       {
90875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (std::exception& e) {
90878       {
90879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90880       };
90881     } catch (...) {
90882       {
90883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90884       };
90885     }
90886   }
90887   jresult = (unsigned long)result;
90888   return jresult;
90889 }
90890
90891
90892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90893   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90894   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90895
90896   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90897   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90898   {
90899     try {
90900       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90901     } catch (std::out_of_range& e) {
90902       {
90903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90904       };
90905     } catch (std::exception& e) {
90906       {
90907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90908       };
90909     } catch (...) {
90910       {
90911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90912       };
90913     }
90914   }
90915 }
90916
90917
90918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90919   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90920   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90921
90922   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90923   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90924   {
90925     try {
90926       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90927     } catch (std::out_of_range& e) {
90928       {
90929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90930       };
90931     } catch (std::exception& e) {
90932       {
90933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90934       };
90935     } catch (...) {
90936       {
90937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90938       };
90939     }
90940   }
90941 }
90942
90943
90944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90945   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90946   Dali::Toolkit::PageTurnView arg2 ;
90947   Dali::Toolkit::PageTurnView *argp2 ;
90948
90949   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90950   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90951   if (!argp2) {
90952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90953     return ;
90954   }
90955   arg2 = *argp2;
90956   {
90957     try {
90958       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90959     } catch (std::out_of_range& e) {
90960       {
90961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90962       };
90963     } catch (std::exception& e) {
90964       {
90965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90966       };
90967     } catch (...) {
90968       {
90969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90970       };
90971     }
90972   }
90973 }
90974
90975
90976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90977   void * jresult ;
90978   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90979
90980   {
90981     try {
90982       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90983     } catch (std::out_of_range& e) {
90984       {
90985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90986       };
90987     } catch (std::exception& e) {
90988       {
90989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90990       };
90991     } catch (...) {
90992       {
90993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90994       };
90995     }
90996   }
90997   jresult = (void *)result;
90998   return jresult;
90999 }
91000
91001
91002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91003   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91004
91005   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91006   {
91007     try {
91008       delete arg1;
91009     } catch (std::out_of_range& e) {
91010       {
91011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91012       };
91013     } catch (std::exception& e) {
91014       {
91015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91016       };
91017     } catch (...) {
91018       {
91019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91020       };
91021     }
91022   }
91023 }
91024
91025
91026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91027   unsigned int jresult ;
91028   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91029   bool result;
91030
91031   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91032   {
91033     try {
91034       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);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91042       };
91043     } catch (...) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91046       };
91047     }
91048   }
91049   jresult = result;
91050   return jresult;
91051 }
91052
91053
91054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91055   unsigned long jresult ;
91056   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91057   std::size_t result;
91058
91059   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91060   {
91061     try {
91062       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);
91063     } catch (std::out_of_range& e) {
91064       {
91065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91066       };
91067     } catch (std::exception& e) {
91068       {
91069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91070       };
91071     } catch (...) {
91072       {
91073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91074       };
91075     }
91076   }
91077   jresult = (unsigned long)result;
91078   return jresult;
91079 }
91080
91081
91082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91083   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91084   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91085
91086   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91087   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91088   {
91089     try {
91090       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91091     } catch (std::out_of_range& e) {
91092       {
91093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91094       };
91095     } catch (std::exception& e) {
91096       {
91097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91098       };
91099     } catch (...) {
91100       {
91101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91102       };
91103     }
91104   }
91105 }
91106
91107
91108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91109   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91110   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91111
91112   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91113   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91114   {
91115     try {
91116       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91117     } catch (std::out_of_range& e) {
91118       {
91119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91120       };
91121     } catch (std::exception& e) {
91122       {
91123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91124       };
91125     } catch (...) {
91126       {
91127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91128       };
91129     }
91130   }
91131 }
91132
91133
91134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91135   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91136   Dali::Toolkit::ProgressBar arg2 ;
91137   float arg3 ;
91138   float arg4 ;
91139   Dali::Toolkit::ProgressBar *argp2 ;
91140
91141   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91142   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91143   if (!argp2) {
91144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91145     return ;
91146   }
91147   arg2 = *argp2;
91148   arg3 = (float)jarg3;
91149   arg4 = (float)jarg4;
91150   {
91151     try {
91152       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91153     } catch (std::out_of_range& e) {
91154       {
91155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91156       };
91157     } catch (std::exception& e) {
91158       {
91159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91160       };
91161     } catch (...) {
91162       {
91163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91164       };
91165     }
91166   }
91167 }
91168
91169
91170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91171   void * jresult ;
91172   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91173
91174   {
91175     try {
91176       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91177     } catch (std::out_of_range& e) {
91178       {
91179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91180       };
91181     } catch (std::exception& e) {
91182       {
91183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91184       };
91185     } catch (...) {
91186       {
91187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91188       };
91189     }
91190   }
91191   jresult = (void *)result;
91192   return jresult;
91193 }
91194
91195
91196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91197   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91198
91199   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91200   {
91201     try {
91202       delete arg1;
91203     } catch (std::out_of_range& e) {
91204       {
91205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91206       };
91207     } catch (std::exception& e) {
91208       {
91209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91210       };
91211     } catch (...) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91214       };
91215     }
91216   }
91217 }
91218
91219
91220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91221   unsigned int jresult ;
91222   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91223   bool result;
91224
91225   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91226   {
91227     try {
91228       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);
91229     } catch (std::out_of_range& e) {
91230       {
91231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (std::exception& e) {
91234       {
91235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91236       };
91237     } catch (...) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91240       };
91241     }
91242   }
91243   jresult = result;
91244   return jresult;
91245 }
91246
91247
91248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91249   unsigned long jresult ;
91250   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91251   std::size_t result;
91252
91253   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91254   {
91255     try {
91256       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);
91257     } catch (std::out_of_range& e) {
91258       {
91259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91260       };
91261     } catch (std::exception& e) {
91262       {
91263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91264       };
91265     } catch (...) {
91266       {
91267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91268       };
91269     }
91270   }
91271   jresult = (unsigned long)result;
91272   return jresult;
91273 }
91274
91275
91276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91277   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91278   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91279
91280   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91281   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91282   {
91283     try {
91284       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91285     } catch (std::out_of_range& e) {
91286       {
91287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91288       };
91289     } catch (std::exception& e) {
91290       {
91291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91292       };
91293     } catch (...) {
91294       {
91295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91296       };
91297     }
91298   }
91299 }
91300
91301
91302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91303   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91304   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91305
91306   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91307   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91308   {
91309     try {
91310       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91311     } catch (std::out_of_range& e) {
91312       {
91313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91314       };
91315     } catch (std::exception& e) {
91316       {
91317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91318       };
91319     } catch (...) {
91320       {
91321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91322       };
91323     }
91324   }
91325 }
91326
91327
91328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91329   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91330   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91331
91332   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91333   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91334   if (!arg2) {
91335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91336     return ;
91337   }
91338   {
91339     try {
91340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91341     } catch (std::out_of_range& e) {
91342       {
91343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91344       };
91345     } catch (std::exception& e) {
91346       {
91347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91348       };
91349     } catch (...) {
91350       {
91351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91352       };
91353     }
91354   }
91355 }
91356
91357
91358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91359   void * jresult ;
91360   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91361
91362   {
91363     try {
91364       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91372       };
91373     } catch (...) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91376       };
91377     }
91378   }
91379   jresult = (void *)result;
91380   return jresult;
91381 }
91382
91383
91384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91385   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91386
91387   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91388   {
91389     try {
91390       delete arg1;
91391     } catch (std::out_of_range& e) {
91392       {
91393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91394       };
91395     } catch (std::exception& e) {
91396       {
91397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91398       };
91399     } catch (...) {
91400       {
91401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91402       };
91403     }
91404   }
91405 }
91406
91407
91408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91409   unsigned int jresult ;
91410   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91411   bool result;
91412
91413   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91414   {
91415     try {
91416       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91417     } catch (std::out_of_range& e) {
91418       {
91419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91420       };
91421     } catch (std::exception& e) {
91422       {
91423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91424       };
91425     } catch (...) {
91426       {
91427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91428       };
91429     }
91430   }
91431   jresult = result;
91432   return jresult;
91433 }
91434
91435
91436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91437   unsigned long jresult ;
91438   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91439   std::size_t result;
91440
91441   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91442   {
91443     try {
91444       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91445     } catch (std::out_of_range& e) {
91446       {
91447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91448       };
91449     } catch (std::exception& e) {
91450       {
91451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91452       };
91453     } catch (...) {
91454       {
91455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91456       };
91457     }
91458   }
91459   jresult = (unsigned long)result;
91460   return jresult;
91461 }
91462
91463
91464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91465   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91466   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91467
91468   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91469   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91470   {
91471     try {
91472       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91473     } catch (std::out_of_range& e) {
91474       {
91475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91476       };
91477     } catch (std::exception& e) {
91478       {
91479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91480       };
91481     } catch (...) {
91482       {
91483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91484       };
91485     }
91486   }
91487 }
91488
91489
91490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91491   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91492   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91493
91494   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91495   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91496   {
91497     try {
91498       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91499     } catch (std::out_of_range& e) {
91500       {
91501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91502       };
91503     } catch (std::exception& e) {
91504       {
91505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91506       };
91507     } catch (...) {
91508       {
91509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91510       };
91511     }
91512   }
91513 }
91514
91515
91516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91517   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91518   Dali::Vector2 *arg2 = 0 ;
91519
91520   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91521   arg2 = (Dali::Vector2 *)jarg2;
91522   if (!arg2) {
91523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91524     return ;
91525   }
91526   {
91527     try {
91528       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91529     } catch (std::out_of_range& e) {
91530       {
91531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91532       };
91533     } catch (std::exception& e) {
91534       {
91535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91536       };
91537     } catch (...) {
91538       {
91539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91540       };
91541     }
91542   }
91543 }
91544
91545
91546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91547   void * jresult ;
91548   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91549
91550   {
91551     try {
91552       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91553     } catch (std::out_of_range& e) {
91554       {
91555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91556       };
91557     } catch (std::exception& e) {
91558       {
91559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91560       };
91561     } catch (...) {
91562       {
91563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91564       };
91565     }
91566   }
91567   jresult = (void *)result;
91568   return jresult;
91569 }
91570
91571
91572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91573   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91574
91575   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91576   {
91577     try {
91578       delete arg1;
91579     } catch (std::out_of_range& e) {
91580       {
91581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91582       };
91583     } catch (std::exception& e) {
91584       {
91585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91586       };
91587     } catch (...) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91590       };
91591     }
91592   }
91593 }
91594
91595
91596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91597   unsigned int jresult ;
91598   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91599   bool result;
91600
91601   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91602   {
91603     try {
91604       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91605     } catch (std::out_of_range& e) {
91606       {
91607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91608       };
91609     } catch (std::exception& e) {
91610       {
91611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91612       };
91613     } catch (...) {
91614       {
91615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91616       };
91617     }
91618   }
91619   jresult = result;
91620   return jresult;
91621 }
91622
91623
91624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91625   unsigned long jresult ;
91626   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91627   std::size_t result;
91628
91629   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91630   {
91631     try {
91632       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91633     } catch (std::out_of_range& e) {
91634       {
91635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91636       };
91637     } catch (std::exception& e) {
91638       {
91639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91640       };
91641     } catch (...) {
91642       {
91643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91644       };
91645     }
91646   }
91647   jresult = (unsigned long)result;
91648   return jresult;
91649 }
91650
91651
91652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91653   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91654   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91655
91656   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91657   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91658   {
91659     try {
91660       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91661     } catch (std::out_of_range& e) {
91662       {
91663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91664       };
91665     } catch (std::exception& e) {
91666       {
91667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91668       };
91669     } catch (...) {
91670       {
91671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91672       };
91673     }
91674   }
91675 }
91676
91677
91678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91679   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91680   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91681
91682   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91683   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91684   {
91685     try {
91686       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91687     } catch (std::out_of_range& e) {
91688       {
91689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91690       };
91691     } catch (std::exception& e) {
91692       {
91693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91694       };
91695     } catch (...) {
91696       {
91697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91698       };
91699     }
91700   }
91701 }
91702
91703
91704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91705   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91706   Dali::Toolkit::TextEditor arg2 ;
91707   Dali::Toolkit::TextEditor *argp2 ;
91708
91709   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91710   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91711   if (!argp2) {
91712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91713     return ;
91714   }
91715   arg2 = *argp2;
91716   {
91717     try {
91718       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91719     } catch (std::out_of_range& e) {
91720       {
91721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91722       };
91723     } catch (std::exception& e) {
91724       {
91725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91726       };
91727     } catch (...) {
91728       {
91729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91730       };
91731     }
91732   }
91733 }
91734
91735
91736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91737   void * jresult ;
91738   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91739
91740   {
91741     try {
91742       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91743     } catch (std::out_of_range& e) {
91744       {
91745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91746       };
91747     } catch (std::exception& e) {
91748       {
91749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91754       };
91755     }
91756   }
91757   jresult = (void *)result;
91758   return jresult;
91759 }
91760
91761
91762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91763   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91764
91765   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91766   {
91767     try {
91768       delete arg1;
91769     } catch (std::out_of_range& e) {
91770       {
91771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (std::exception& e) {
91774       {
91775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91776       };
91777     } catch (...) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91780       };
91781     }
91782   }
91783 }
91784
91785
91786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91787   unsigned int jresult ;
91788   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91789   bool result;
91790
91791   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91792   {
91793     try {
91794       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91795     } catch (std::out_of_range& e) {
91796       {
91797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91798       };
91799     } catch (std::exception& e) {
91800       {
91801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91802       };
91803     } catch (...) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91806       };
91807     }
91808   }
91809   jresult = result;
91810   return jresult;
91811 }
91812
91813
91814 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91815   unsigned long jresult ;
91816   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91817   std::size_t result;
91818
91819   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91820   {
91821     try {
91822       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91823     } catch (std::out_of_range& e) {
91824       {
91825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91826       };
91827     } catch (std::exception& e) {
91828       {
91829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91830       };
91831     } catch (...) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91834       };
91835     }
91836   }
91837   jresult = (unsigned long)result;
91838   return jresult;
91839 }
91840
91841
91842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91843   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91844   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91845
91846   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91847   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91848   {
91849     try {
91850       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91851     } catch (std::out_of_range& e) {
91852       {
91853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91854       };
91855     } catch (std::exception& e) {
91856       {
91857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91858       };
91859     } catch (...) {
91860       {
91861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91862       };
91863     }
91864   }
91865 }
91866
91867
91868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91869   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91870   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91871
91872   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91873   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91874   {
91875     try {
91876       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91877     } catch (std::out_of_range& e) {
91878       {
91879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91880       };
91881     } catch (std::exception& e) {
91882       {
91883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91884       };
91885     } catch (...) {
91886       {
91887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91888       };
91889     }
91890   }
91891 }
91892
91893
91894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91895   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91896   Dali::Toolkit::TextField arg2 ;
91897   Dali::Toolkit::TextField *argp2 ;
91898
91899   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91900   argp2 = (Dali::Toolkit::TextField *)jarg2;
91901   if (!argp2) {
91902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91903     return ;
91904   }
91905   arg2 = *argp2;
91906   {
91907     try {
91908       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91909     } catch (std::out_of_range& e) {
91910       {
91911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91912       };
91913     } catch (std::exception& e) {
91914       {
91915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91916       };
91917     } catch (...) {
91918       {
91919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91920       };
91921     }
91922   }
91923 }
91924
91925
91926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91927   void * jresult ;
91928   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91929
91930   {
91931     try {
91932       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91933     } catch (std::out_of_range& e) {
91934       {
91935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91936       };
91937     } catch (std::exception& e) {
91938       {
91939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91940       };
91941     } catch (...) {
91942       {
91943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91944       };
91945     }
91946   }
91947   jresult = (void *)result;
91948   return jresult;
91949 }
91950
91951
91952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91953   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91954
91955   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91956   {
91957     try {
91958       delete arg1;
91959     } catch (std::out_of_range& e) {
91960       {
91961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91962       };
91963     } catch (std::exception& e) {
91964       {
91965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91966       };
91967     } catch (...) {
91968       {
91969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91970       };
91971     }
91972   }
91973 }
91974
91975
91976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91977   unsigned int jresult ;
91978   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91979   bool result;
91980
91981   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91982   {
91983     try {
91984       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);
91985     } catch (std::out_of_range& e) {
91986       {
91987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91988       };
91989     } catch (std::exception& e) {
91990       {
91991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91992       };
91993     } catch (...) {
91994       {
91995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91996       };
91997     }
91998   }
91999   jresult = result;
92000   return jresult;
92001 }
92002
92003
92004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92005   unsigned long jresult ;
92006   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92007   std::size_t result;
92008
92009   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92010   {
92011     try {
92012       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);
92013     } catch (std::out_of_range& e) {
92014       {
92015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92016       };
92017     } catch (std::exception& e) {
92018       {
92019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92020       };
92021     } catch (...) {
92022       {
92023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92024       };
92025     }
92026   }
92027   jresult = (unsigned long)result;
92028   return jresult;
92029 }
92030
92031
92032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92033   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92034   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92035
92036   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92037   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92038   {
92039     try {
92040       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92041     } catch (std::out_of_range& e) {
92042       {
92043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92044       };
92045     } catch (std::exception& e) {
92046       {
92047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92048       };
92049     } catch (...) {
92050       {
92051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92052       };
92053     }
92054   }
92055 }
92056
92057
92058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92059   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92060   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92061
92062   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92063   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92064   {
92065     try {
92066       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92067     } catch (std::out_of_range& e) {
92068       {
92069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92070       };
92071     } catch (std::exception& e) {
92072       {
92073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92074       };
92075     } catch (...) {
92076       {
92077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92078       };
92079     }
92080   }
92081 }
92082
92083
92084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92085   unsigned int jresult ;
92086   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92087   Dali::Toolkit::Control arg2 ;
92088   Dali::KeyEvent *arg3 = 0 ;
92089   Dali::Toolkit::Control *argp2 ;
92090   bool result;
92091
92092   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92093   argp2 = (Dali::Toolkit::Control *)jarg2;
92094   if (!argp2) {
92095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92096     return 0;
92097   }
92098   arg2 = *argp2;
92099   arg3 = (Dali::KeyEvent *)jarg3;
92100   if (!arg3) {
92101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92102     return 0;
92103   }
92104   {
92105     try {
92106       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);
92107     } catch (std::out_of_range& e) {
92108       {
92109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92110       };
92111     } catch (std::exception& e) {
92112       {
92113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92114       };
92115     } catch (...) {
92116       {
92117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92118       };
92119     }
92120   }
92121   jresult = result;
92122   return jresult;
92123 }
92124
92125
92126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92127   void * jresult ;
92128   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92129
92130   {
92131     try {
92132       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92133     } catch (std::out_of_range& e) {
92134       {
92135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92136       };
92137     } catch (std::exception& e) {
92138       {
92139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (...) {
92142       {
92143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92144       };
92145     }
92146   }
92147   jresult = (void *)result;
92148   return jresult;
92149 }
92150
92151
92152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92153   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92154
92155   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92156   {
92157     try {
92158       delete arg1;
92159     } catch (std::out_of_range& e) {
92160       {
92161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92162       };
92163     } catch (std::exception& e) {
92164       {
92165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92166       };
92167     } catch (...) {
92168       {
92169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92170       };
92171     }
92172   }
92173 }
92174
92175
92176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92177   unsigned int jresult ;
92178   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92179   bool result;
92180
92181   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92182   {
92183     try {
92184       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92185     } catch (std::out_of_range& e) {
92186       {
92187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92188       };
92189     } catch (std::exception& e) {
92190       {
92191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92192       };
92193     } catch (...) {
92194       {
92195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92196       };
92197     }
92198   }
92199   jresult = result;
92200   return jresult;
92201 }
92202
92203
92204 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92205   unsigned long jresult ;
92206   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92207   std::size_t result;
92208
92209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92210   {
92211     try {
92212       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92213     } catch (std::out_of_range& e) {
92214       {
92215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92216       };
92217     } catch (std::exception& e) {
92218       {
92219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (...) {
92222       {
92223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92224       };
92225     }
92226   }
92227   jresult = (unsigned long)result;
92228   return jresult;
92229 }
92230
92231
92232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92233   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92234   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92235
92236   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92237   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92238   {
92239     try {
92240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92241     } catch (std::out_of_range& e) {
92242       {
92243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92244       };
92245     } catch (std::exception& e) {
92246       {
92247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92248       };
92249     } catch (...) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92252       };
92253     }
92254   }
92255 }
92256
92257
92258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92259   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92260   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92261
92262   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92263   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92264   {
92265     try {
92266       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92267     } catch (std::out_of_range& e) {
92268       {
92269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92270       };
92271     } catch (std::exception& e) {
92272       {
92273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92274       };
92275     } catch (...) {
92276       {
92277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92278       };
92279     }
92280   }
92281 }
92282
92283
92284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92285   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92286   Dali::Toolkit::Control arg2 ;
92287   Dali::Toolkit::Control *argp2 ;
92288
92289   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92290   argp2 = (Dali::Toolkit::Control *)jarg2;
92291   if (!argp2) {
92292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92293     return ;
92294   }
92295   arg2 = *argp2;
92296   {
92297     try {
92298       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92299     } catch (std::out_of_range& e) {
92300       {
92301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92302       };
92303     } catch (std::exception& e) {
92304       {
92305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92306       };
92307     } catch (...) {
92308       {
92309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92310       };
92311     }
92312   }
92313 }
92314
92315
92316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92317   void * jresult ;
92318   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92319
92320   {
92321     try {
92322       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92323     } catch (std::out_of_range& e) {
92324       {
92325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92326       };
92327     } catch (std::exception& e) {
92328       {
92329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92330       };
92331     } catch (...) {
92332       {
92333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92334       };
92335     }
92336   }
92337   jresult = (void *)result;
92338   return jresult;
92339 }
92340
92341
92342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92343   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92344
92345   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92346   {
92347     try {
92348       delete arg1;
92349     } catch (std::out_of_range& e) {
92350       {
92351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92352       };
92353     } catch (std::exception& e) {
92354       {
92355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92356       };
92357     } catch (...) {
92358       {
92359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92360       };
92361     }
92362   }
92363 }
92364
92365
92366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92367   unsigned int jresult ;
92368   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92369   bool result;
92370
92371   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92372   {
92373     try {
92374       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92375     } catch (std::out_of_range& e) {
92376       {
92377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92378       };
92379     } catch (std::exception& e) {
92380       {
92381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92382       };
92383     } catch (...) {
92384       {
92385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92386       };
92387     }
92388   }
92389   jresult = result;
92390   return jresult;
92391 }
92392
92393
92394 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92395   unsigned long jresult ;
92396   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92397   std::size_t result;
92398
92399   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92400   {
92401     try {
92402       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92403     } catch (std::out_of_range& e) {
92404       {
92405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92406       };
92407     } catch (std::exception& e) {
92408       {
92409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92410       };
92411     } catch (...) {
92412       {
92413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92414       };
92415     }
92416   }
92417   jresult = (unsigned long)result;
92418   return jresult;
92419 }
92420
92421
92422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92423   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92424   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92425
92426   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92427   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92428   {
92429     try {
92430       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92431     } catch (std::out_of_range& e) {
92432       {
92433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92434       };
92435     } catch (std::exception& e) {
92436       {
92437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92438       };
92439     } catch (...) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92442       };
92443     }
92444   }
92445 }
92446
92447
92448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92449   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92450   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92451
92452   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92453   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92454   {
92455     try {
92456       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92457     } catch (std::out_of_range& e) {
92458       {
92459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92460       };
92461     } catch (std::exception& e) {
92462       {
92463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92464       };
92465     } catch (...) {
92466       {
92467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92468       };
92469     }
92470   }
92471 }
92472
92473
92474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92475   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92476   Dali::Toolkit::VideoView *arg2 = 0 ;
92477
92478   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92479   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92480   if (!arg2) {
92481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92482     return ;
92483   }
92484   {
92485     try {
92486       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92487     } catch (std::out_of_range& e) {
92488       {
92489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92490       };
92491     } catch (std::exception& e) {
92492       {
92493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92494       };
92495     } catch (...) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92498       };
92499     }
92500   }
92501 }
92502
92503
92504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92505   void * jresult ;
92506   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92507
92508   {
92509     try {
92510       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92511     } catch (std::out_of_range& e) {
92512       {
92513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92514       };
92515     } catch (std::exception& e) {
92516       {
92517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92522       };
92523     }
92524   }
92525   jresult = (void *)result;
92526   return jresult;
92527 }
92528
92529
92530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92531   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92532
92533   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92534   {
92535     try {
92536       delete arg1;
92537     } catch (std::out_of_range& e) {
92538       {
92539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92540       };
92541     } catch (std::exception& e) {
92542       {
92543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92544       };
92545     } catch (...) {
92546       {
92547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92548       };
92549     }
92550   }
92551 }
92552
92553
92554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92555   unsigned int jresult ;
92556   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92557   bool result;
92558
92559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92560   {
92561     try {
92562       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92563     } catch (std::out_of_range& e) {
92564       {
92565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92566       };
92567     } catch (std::exception& e) {
92568       {
92569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92570       };
92571     } catch (...) {
92572       {
92573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92574       };
92575     }
92576   }
92577   jresult = result;
92578   return jresult;
92579 }
92580
92581
92582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92583   unsigned long jresult ;
92584   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92585   std::size_t result;
92586
92587   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92588   {
92589     try {
92590       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92591     } catch (std::out_of_range& e) {
92592       {
92593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92594       };
92595     } catch (std::exception& e) {
92596       {
92597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92598       };
92599     } catch (...) {
92600       {
92601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92602       };
92603     }
92604   }
92605   jresult = (unsigned long)result;
92606   return jresult;
92607 }
92608
92609
92610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92611   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92612   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92613
92614   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92615   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92616   {
92617     try {
92618       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92619     } catch (std::out_of_range& e) {
92620       {
92621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92622       };
92623     } catch (std::exception& e) {
92624       {
92625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92626       };
92627     } catch (...) {
92628       {
92629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92630       };
92631     }
92632   }
92633 }
92634
92635
92636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92637   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92638   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92639
92640   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92641   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92642   {
92643     try {
92644       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92645     } catch (std::out_of_range& e) {
92646       {
92647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92648       };
92649     } catch (std::exception& e) {
92650       {
92651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92652       };
92653     } catch (...) {
92654       {
92655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92656       };
92657     }
92658   }
92659 }
92660
92661
92662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92663   unsigned int jresult ;
92664   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92665   Dali::Toolkit::Slider arg2 ;
92666   float arg3 ;
92667   Dali::Toolkit::Slider *argp2 ;
92668   bool result;
92669
92670   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92671   argp2 = (Dali::Toolkit::Slider *)jarg2;
92672   if (!argp2) {
92673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92674     return 0;
92675   }
92676   arg2 = *argp2;
92677   arg3 = (float)jarg3;
92678   {
92679     try {
92680       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92681     } catch (std::out_of_range& e) {
92682       {
92683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92684       };
92685     } catch (std::exception& e) {
92686       {
92687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92688       };
92689     } catch (...) {
92690       {
92691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92692       };
92693     }
92694   }
92695   jresult = result;
92696   return jresult;
92697 }
92698
92699
92700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92701   void * jresult ;
92702   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92703
92704   {
92705     try {
92706       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92707     } catch (std::out_of_range& e) {
92708       {
92709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92710       };
92711     } catch (std::exception& e) {
92712       {
92713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92714       };
92715     } catch (...) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92718       };
92719     }
92720   }
92721   jresult = (void *)result;
92722   return jresult;
92723 }
92724
92725
92726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92727   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92728
92729   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92730   {
92731     try {
92732       delete arg1;
92733     } catch (std::out_of_range& e) {
92734       {
92735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92736       };
92737     } catch (std::exception& e) {
92738       {
92739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92740       };
92741     } catch (...) {
92742       {
92743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92744       };
92745     }
92746   }
92747 }
92748
92749
92750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92751   unsigned int jresult ;
92752   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92753   bool result;
92754
92755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92756   {
92757     try {
92758       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92759     } catch (std::out_of_range& e) {
92760       {
92761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92762       };
92763     } catch (std::exception& e) {
92764       {
92765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92766       };
92767     } catch (...) {
92768       {
92769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92770       };
92771     }
92772   }
92773   jresult = result;
92774   return jresult;
92775 }
92776
92777
92778 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92779   unsigned long jresult ;
92780   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92781   std::size_t result;
92782
92783   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92784   {
92785     try {
92786       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92787     } catch (std::out_of_range& e) {
92788       {
92789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92790       };
92791     } catch (std::exception& e) {
92792       {
92793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92794       };
92795     } catch (...) {
92796       {
92797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92798       };
92799     }
92800   }
92801   jresult = (unsigned long)result;
92802   return jresult;
92803 }
92804
92805
92806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92807   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92808   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92809
92810   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92811   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92812   {
92813     try {
92814       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92815     } catch (std::out_of_range& e) {
92816       {
92817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92818       };
92819     } catch (std::exception& e) {
92820       {
92821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92822       };
92823     } catch (...) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92826       };
92827     }
92828   }
92829 }
92830
92831
92832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92833   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92834   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92835
92836   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92837   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92838   {
92839     try {
92840       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92841     } catch (std::out_of_range& e) {
92842       {
92843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92844       };
92845     } catch (std::exception& e) {
92846       {
92847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92848       };
92849     } catch (...) {
92850       {
92851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92852       };
92853     }
92854   }
92855 }
92856
92857
92858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92859   unsigned int jresult ;
92860   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92861   Dali::Toolkit::Slider arg2 ;
92862   int arg3 ;
92863   Dali::Toolkit::Slider *argp2 ;
92864   bool result;
92865
92866   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92867   argp2 = (Dali::Toolkit::Slider *)jarg2;
92868   if (!argp2) {
92869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92870     return 0;
92871   }
92872   arg2 = *argp2;
92873   arg3 = (int)jarg3;
92874   {
92875     try {
92876       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92877     } catch (std::out_of_range& e) {
92878       {
92879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92880       };
92881     } catch (std::exception& e) {
92882       {
92883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92884       };
92885     } catch (...) {
92886       {
92887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92888       };
92889     }
92890   }
92891   jresult = result;
92892   return jresult;
92893 }
92894
92895
92896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92897   void * jresult ;
92898   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92899
92900   {
92901     try {
92902       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92903     } catch (std::out_of_range& e) {
92904       {
92905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92906       };
92907     } catch (std::exception& e) {
92908       {
92909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92910       };
92911     } catch (...) {
92912       {
92913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92914       };
92915     }
92916   }
92917   jresult = (void *)result;
92918   return jresult;
92919 }
92920
92921
92922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92923   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92924
92925   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92926   {
92927     try {
92928       delete arg1;
92929     } catch (std::out_of_range& e) {
92930       {
92931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92932       };
92933     } catch (std::exception& e) {
92934       {
92935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92936       };
92937     } catch (...) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92940       };
92941     }
92942   }
92943 }
92944
92945
92946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92947   void * jresult ;
92948   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92949
92950   {
92951     try {
92952       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92953     } catch (std::out_of_range& e) {
92954       {
92955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92956       };
92957     } catch (std::exception& e) {
92958       {
92959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92960       };
92961     } catch (...) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92964       };
92965     }
92966   }
92967   jresult = (void *)result;
92968   return jresult;
92969 }
92970
92971
92972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92973   void * jresult ;
92974   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92976
92977   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92978   {
92979     try {
92980       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92981     } catch (std::out_of_range& e) {
92982       {
92983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92984       };
92985     } catch (std::exception& e) {
92986       {
92987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92988       };
92989     } catch (...) {
92990       {
92991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92992       };
92993     }
92994   }
92995   jresult = (void *)result;
92996   return jresult;
92997 }
92998
92999
93000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93001   void * jresult ;
93002   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93004
93005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93006   if (!arg1) {
93007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93008     return 0;
93009   }
93010   {
93011     try {
93012       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93013     } catch (std::out_of_range& e) {
93014       {
93015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93016       };
93017     } catch (std::exception& e) {
93018       {
93019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93020       };
93021     } catch (...) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93024       };
93025     }
93026   }
93027   jresult = (void *)result;
93028   return jresult;
93029 }
93030
93031
93032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93034
93035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93036   {
93037     try {
93038       delete arg1;
93039     } catch (std::out_of_range& e) {
93040       {
93041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93042       };
93043     } catch (std::exception& e) {
93044       {
93045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93046       };
93047     } catch (...) {
93048       {
93049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93050       };
93051     }
93052   }
93053 }
93054
93055
93056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93057   void * jresult ;
93058   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93059   Dali::Toolkit::Ruler *result = 0 ;
93060
93061   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93062   {
93063     try {
93064       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93065     } catch (std::out_of_range& e) {
93066       {
93067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93068       };
93069     } catch (std::exception& e) {
93070       {
93071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93072       };
93073     } catch (...) {
93074       {
93075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93076       };
93077     }
93078   }
93079   jresult = (void *)result;
93080   return jresult;
93081 }
93082
93083
93084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93085   void * jresult ;
93086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93087   Dali::Toolkit::Ruler *result = 0 ;
93088
93089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93090   {
93091     try {
93092       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93093     } catch (std::out_of_range& e) {
93094       {
93095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93096       };
93097     } catch (std::exception& e) {
93098       {
93099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93100       };
93101     } catch (...) {
93102       {
93103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93104       };
93105     }
93106   }
93107   jresult = (void *)result;
93108   return jresult;
93109 }
93110
93111
93112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93113   void * jresult ;
93114   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93115   Dali::Toolkit::Ruler *result = 0 ;
93116
93117   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93118   {
93119     try {
93120       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93121     } catch (std::out_of_range& e) {
93122       {
93123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93124       };
93125     } catch (std::exception& e) {
93126       {
93127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93128       };
93129     } catch (...) {
93130       {
93131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93132       };
93133     }
93134   }
93135   jresult = (void *)result;
93136   return jresult;
93137 }
93138
93139
93140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93141   void * jresult ;
93142   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93143   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93144   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93145
93146   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93147   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93148   if (!arg2) {
93149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93150     return 0;
93151   }
93152   {
93153     try {
93154       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93155     } catch (std::out_of_range& e) {
93156       {
93157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93158       };
93159     } catch (std::exception& e) {
93160       {
93161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93162       };
93163     } catch (...) {
93164       {
93165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93166       };
93167     }
93168   }
93169   jresult = (void *)result;
93170   return jresult;
93171 }
93172
93173
93174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93175   void * jresult ;
93176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93177   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93178   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93179
93180   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93181   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93182   {
93183     try {
93184       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93185     } catch (std::out_of_range& e) {
93186       {
93187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93188       };
93189     } catch (std::exception& e) {
93190       {
93191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93192       };
93193     } catch (...) {
93194       {
93195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93196       };
93197     }
93198   }
93199   jresult = (void *)result;
93200   return jresult;
93201 }
93202
93203
93204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93205   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93206
93207   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93208   {
93209     try {
93210       (arg1)->Reset();
93211     } catch (std::out_of_range& e) {
93212       {
93213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93214       };
93215     } catch (std::exception& e) {
93216       {
93217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93218       };
93219     } catch (...) {
93220       {
93221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93222       };
93223     }
93224   }
93225 }
93226
93227
93228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93229   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93230   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93231
93232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93233   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93234   {
93235     try {
93236       (arg1)->Reset(arg2);
93237     } catch (std::out_of_range& e) {
93238       {
93239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93240       };
93241     } catch (std::exception& e) {
93242       {
93243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93244       };
93245     } catch (...) {
93246       {
93247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93248       };
93249     }
93250   }
93251 }
93252
93253
93254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93255   void * jresult ;
93256   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93257   Dali::Toolkit::Ruler *result = 0 ;
93258
93259   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93260   {
93261     try {
93262       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93263     } catch (std::out_of_range& e) {
93264       {
93265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93266       };
93267     } catch (std::exception& e) {
93268       {
93269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93270       };
93271     } catch (...) {
93272       {
93273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93274       };
93275     }
93276   }
93277   jresult = (void *)result;
93278   return jresult;
93279 }
93280
93281
93282 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93283   float jresult ;
93284   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93285   float arg2 ;
93286   float arg3 ;
93287   float result;
93288
93289   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93290   arg2 = (float)jarg2;
93291   arg3 = (float)jarg3;
93292   {
93293     try {
93294       result = (float)(*arg1)->Snap(arg2,arg3);
93295     } catch (std::out_of_range& e) {
93296       {
93297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93298       };
93299     } catch (std::exception& e) {
93300       {
93301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93302       };
93303     } catch (...) {
93304       {
93305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93306       };
93307     }
93308   }
93309   jresult = result;
93310   return jresult;
93311 }
93312
93313
93314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93315   float jresult ;
93316   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93317   float arg2 ;
93318   float result;
93319
93320   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93321   arg2 = (float)jarg2;
93322   {
93323     try {
93324       result = (float)(*arg1)->Snap(arg2);
93325     } catch (std::out_of_range& e) {
93326       {
93327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93328       };
93329     } catch (std::exception& e) {
93330       {
93331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93332       };
93333     } catch (...) {
93334       {
93335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93336       };
93337     }
93338   }
93339   jresult = result;
93340   return jresult;
93341 }
93342
93343
93344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93345   float jresult ;
93346   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93347   unsigned int arg2 ;
93348   unsigned int *arg3 = 0 ;
93349   bool arg4 ;
93350   float result;
93351
93352   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93353   arg2 = (unsigned int)jarg2;
93354   arg3 = (unsigned int *)jarg3;
93355   arg4 = jarg4 ? true : false;
93356   {
93357     try {
93358       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93359     } catch (std::out_of_range& e) {
93360       {
93361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93362       };
93363     } catch (std::exception& e) {
93364       {
93365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93366       };
93367     } catch (...) {
93368       {
93369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93370       };
93371     }
93372   }
93373   jresult = result;
93374   return jresult;
93375 }
93376
93377
93378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93379   unsigned int jresult ;
93380   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93381   float arg2 ;
93382   bool arg3 ;
93383   unsigned int result;
93384
93385   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93386   arg2 = (float)jarg2;
93387   arg3 = jarg3 ? true : false;
93388   {
93389     try {
93390       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93391     } catch (std::out_of_range& e) {
93392       {
93393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93394       };
93395     } catch (std::exception& e) {
93396       {
93397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93398       };
93399     } catch (...) {
93400       {
93401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93402       };
93403     }
93404   }
93405   jresult = result;
93406   return jresult;
93407 }
93408
93409
93410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93411   unsigned int jresult ;
93412   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93413   unsigned int result;
93414
93415   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93416   {
93417     try {
93418       result = (unsigned int)(*arg1)->GetTotalPages();
93419     } catch (std::out_of_range& e) {
93420       {
93421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93422       };
93423     } catch (std::exception& e) {
93424       {
93425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (...) {
93428       {
93429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93430       };
93431     }
93432   }
93433   jresult = result;
93434   return jresult;
93435 }
93436
93437
93438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93439   int jresult ;
93440   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93441   Dali::Toolkit::Ruler::RulerType result;
93442
93443   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93444   {
93445     try {
93446       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93447     } catch (std::out_of_range& e) {
93448       {
93449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93450       };
93451     } catch (std::exception& e) {
93452       {
93453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93454       };
93455     } catch (...) {
93456       {
93457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93458       };
93459     }
93460   }
93461   jresult = (int)result;
93462   return jresult;
93463 }
93464
93465
93466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93467   unsigned int jresult ;
93468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93469   bool result;
93470
93471   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93472   {
93473     try {
93474       result = (bool)(*arg1)->IsEnabled();
93475     } catch (std::out_of_range& e) {
93476       {
93477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93478       };
93479     } catch (std::exception& e) {
93480       {
93481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93482       };
93483     } catch (...) {
93484       {
93485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93486       };
93487     }
93488   }
93489   jresult = result;
93490   return jresult;
93491 }
93492
93493
93494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93495   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93496
93497   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93498   {
93499     try {
93500       (*arg1)->Enable();
93501     } catch (std::out_of_range& e) {
93502       {
93503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93504       };
93505     } catch (std::exception& e) {
93506       {
93507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93508       };
93509     } catch (...) {
93510       {
93511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93512       };
93513     }
93514   }
93515 }
93516
93517
93518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93520
93521   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93522   {
93523     try {
93524       (*arg1)->Disable();
93525     } catch (std::out_of_range& e) {
93526       {
93527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93528       };
93529     } catch (std::exception& e) {
93530       {
93531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93532       };
93533     } catch (...) {
93534       {
93535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93536       };
93537     }
93538   }
93539 }
93540
93541
93542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93543   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93544   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93545   Dali::Toolkit::RulerDomain *argp2 ;
93546
93547   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93548   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93549   if (!argp2) {
93550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93551     return ;
93552   }
93553   arg2 = *argp2;
93554   {
93555     try {
93556       (*arg1)->SetDomain(arg2);
93557     } catch (std::out_of_range& e) {
93558       {
93559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93560       };
93561     } catch (std::exception& e) {
93562       {
93563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93564       };
93565     } catch (...) {
93566       {
93567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93568       };
93569     }
93570   }
93571 }
93572
93573
93574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93575   void * jresult ;
93576   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93577   Dali::Toolkit::RulerDomain *result = 0 ;
93578
93579   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93580   {
93581     try {
93582       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93583     } catch (std::out_of_range& e) {
93584       {
93585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93586       };
93587     } catch (std::exception& e) {
93588       {
93589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93590       };
93591     } catch (...) {
93592       {
93593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93594       };
93595     }
93596   }
93597   jresult = (void *)result;
93598   return jresult;
93599 }
93600
93601
93602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93603   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93604
93605   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93606   {
93607     try {
93608       (*arg1)->DisableDomain();
93609     } catch (std::out_of_range& e) {
93610       {
93611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93612       };
93613     } catch (std::exception& e) {
93614       {
93615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93616       };
93617     } catch (...) {
93618       {
93619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93620       };
93621     }
93622   }
93623 }
93624
93625
93626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93627   float jresult ;
93628   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93629   float arg2 ;
93630   float arg3 ;
93631   float arg4 ;
93632   float result;
93633
93634   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93635   arg2 = (float)jarg2;
93636   arg3 = (float)jarg3;
93637   arg4 = (float)jarg4;
93638   {
93639     try {
93640       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93641     } catch (std::out_of_range& e) {
93642       {
93643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93644       };
93645     } catch (std::exception& e) {
93646       {
93647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93648       };
93649     } catch (...) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93652       };
93653     }
93654   }
93655   jresult = result;
93656   return jresult;
93657 }
93658
93659
93660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93661   float jresult ;
93662   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93663   float arg2 ;
93664   float arg3 ;
93665   float result;
93666
93667   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93668   arg2 = (float)jarg2;
93669   arg3 = (float)jarg3;
93670   {
93671     try {
93672       result = (float)(*arg1)->Clamp(arg2,arg3);
93673     } catch (std::out_of_range& e) {
93674       {
93675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93676       };
93677     } catch (std::exception& e) {
93678       {
93679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93680       };
93681     } catch (...) {
93682       {
93683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93684       };
93685     }
93686   }
93687   jresult = result;
93688   return jresult;
93689 }
93690
93691
93692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93693   float jresult ;
93694   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93695   float arg2 ;
93696   float result;
93697
93698   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93699   arg2 = (float)jarg2;
93700   {
93701     try {
93702       result = (float)(*arg1)->Clamp(arg2);
93703     } catch (std::out_of_range& e) {
93704       {
93705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93706       };
93707     } catch (std::exception& e) {
93708       {
93709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93710       };
93711     } catch (...) {
93712       {
93713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93714       };
93715     }
93716   }
93717   jresult = result;
93718   return jresult;
93719 }
93720
93721
93722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93723   float jresult ;
93724   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93725   float arg2 ;
93726   float arg3 ;
93727   float arg4 ;
93728   Dali::Toolkit::ClampState *arg5 = 0 ;
93729   float result;
93730
93731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93732   arg2 = (float)jarg2;
93733   arg3 = (float)jarg3;
93734   arg4 = (float)jarg4;
93735   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93736   if (!arg5) {
93737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93738     return 0;
93739   }
93740   {
93741     try {
93742       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93743     } catch (std::out_of_range& e) {
93744       {
93745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93746       };
93747     } catch (std::exception& e) {
93748       {
93749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93750       };
93751     } catch (...) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93754       };
93755     }
93756   }
93757   jresult = result;
93758   return jresult;
93759 }
93760
93761
93762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93763   float jresult ;
93764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93765   float arg2 ;
93766   float arg3 ;
93767   float arg4 ;
93768   float arg5 ;
93769   float result;
93770
93771   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93772   arg2 = (float)jarg2;
93773   arg3 = (float)jarg3;
93774   arg4 = (float)jarg4;
93775   arg5 = (float)jarg5;
93776   {
93777     try {
93778       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93779     } catch (std::out_of_range& e) {
93780       {
93781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93782       };
93783     } catch (std::exception& e) {
93784       {
93785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93786       };
93787     } catch (...) {
93788       {
93789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93790       };
93791     }
93792   }
93793   jresult = result;
93794   return jresult;
93795 }
93796
93797
93798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93799   float jresult ;
93800   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93801   float arg2 ;
93802   float arg3 ;
93803   float arg4 ;
93804   float result;
93805
93806   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93807   arg2 = (float)jarg2;
93808   arg3 = (float)jarg3;
93809   arg4 = (float)jarg4;
93810   {
93811     try {
93812       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93813     } catch (std::out_of_range& e) {
93814       {
93815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93816       };
93817     } catch (std::exception& e) {
93818       {
93819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93820       };
93821     } catch (...) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93824       };
93825     }
93826   }
93827   jresult = result;
93828   return jresult;
93829 }
93830
93831
93832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93833   float jresult ;
93834   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93835   float arg2 ;
93836   float arg3 ;
93837   float result;
93838
93839   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93840   arg2 = (float)jarg2;
93841   arg3 = (float)jarg3;
93842   {
93843     try {
93844       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93852       };
93853     } catch (...) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93856       };
93857     }
93858   }
93859   jresult = result;
93860   return jresult;
93861 }
93862
93863
93864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93865   float jresult ;
93866   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93867   float arg2 ;
93868   float result;
93869
93870   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93871   arg2 = (float)jarg2;
93872   {
93873     try {
93874       result = (float)(*arg1)->SnapAndClamp(arg2);
93875     } catch (std::out_of_range& e) {
93876       {
93877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93878       };
93879     } catch (std::exception& e) {
93880       {
93881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93882       };
93883     } catch (...) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93886       };
93887     }
93888   }
93889   jresult = result;
93890   return jresult;
93891 }
93892
93893
93894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93895   float jresult ;
93896   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93897   float arg2 ;
93898   float arg3 ;
93899   float arg4 ;
93900   float arg5 ;
93901   Dali::Toolkit::ClampState *arg6 = 0 ;
93902   float result;
93903
93904   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93905   arg2 = (float)jarg2;
93906   arg3 = (float)jarg3;
93907   arg4 = (float)jarg4;
93908   arg5 = (float)jarg5;
93909   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93910   if (!arg6) {
93911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93912     return 0;
93913   }
93914   {
93915     try {
93916       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93917     } catch (std::out_of_range& e) {
93918       {
93919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93920       };
93921     } catch (std::exception& e) {
93922       {
93923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93924       };
93925     } catch (...) {
93926       {
93927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93928       };
93929     }
93930   }
93931   jresult = result;
93932   return jresult;
93933 }
93934
93935
93936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93937   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93938
93939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93940   {
93941     try {
93942       (*arg1)->Reference();
93943     } catch (std::out_of_range& e) {
93944       {
93945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93946       };
93947     } catch (std::exception& e) {
93948       {
93949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93950       };
93951     } catch (...) {
93952       {
93953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93954       };
93955     }
93956   }
93957 }
93958
93959
93960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93961   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93962
93963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93964   {
93965     try {
93966       (*arg1)->Unreference();
93967     } catch (std::out_of_range& e) {
93968       {
93969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93970       };
93971     } catch (std::exception& e) {
93972       {
93973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93974       };
93975     } catch (...) {
93976       {
93977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93978       };
93979     }
93980   }
93981 }
93982
93983
93984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93985   int jresult ;
93986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93987   int result;
93988
93989   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93990   {
93991     try {
93992       result = (int)(*arg1)->ReferenceCount();
93993     } catch (std::out_of_range& e) {
93994       {
93995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93996       };
93997     } catch (std::exception& e) {
93998       {
93999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94000       };
94001     } catch (...) {
94002       {
94003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94004       };
94005     }
94006   }
94007   jresult = result;
94008   return jresult;
94009 }
94010
94011
94012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94013   unsigned int jresult ;
94014   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94015   bool result;
94016
94017   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94018   {
94019     try {
94020       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94021     } catch (std::out_of_range& e) {
94022       {
94023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94024       };
94025     } catch (std::exception& e) {
94026       {
94027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94028       };
94029     } catch (...) {
94030       {
94031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94032       };
94033     }
94034   }
94035   jresult = result;
94036   return jresult;
94037 }
94038
94039
94040 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94041   unsigned long jresult ;
94042   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94043   std::size_t result;
94044
94045   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94046   {
94047     try {
94048       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94049     } catch (std::out_of_range& e) {
94050       {
94051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94052       };
94053     } catch (std::exception& e) {
94054       {
94055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94056       };
94057     } catch (...) {
94058       {
94059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94060       };
94061     }
94062   }
94063   jresult = (unsigned long)result;
94064   return jresult;
94065 }
94066
94067
94068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
94069   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94070   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94071
94072   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94073   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94074   {
94075     try {
94076       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94077     } catch (std::out_of_range& e) {
94078       {
94079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94080       };
94081     } catch (std::exception& e) {
94082       {
94083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94084       };
94085     } catch (...) {
94086       {
94087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94088       };
94089     }
94090   }
94091 }
94092
94093
94094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
94095   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94096   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94097
94098   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94099   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94100   {
94101     try {
94102       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94103     } catch (std::out_of_range& e) {
94104       {
94105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94106       };
94107     } catch (std::exception& e) {
94108       {
94109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94110       };
94111     } catch (...) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94114       };
94115     }
94116   }
94117 }
94118
94119
94120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
94121   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94122   Dali::Toolkit::Control arg2 ;
94123   Dali::Toolkit::Control *argp2 ;
94124
94125   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94126   argp2 = (Dali::Toolkit::Control *)jarg2;
94127   if (!argp2) {
94128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94129     return ;
94130   }
94131   arg2 = *argp2;
94132   {
94133     try {
94134       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94135     } catch (std::out_of_range& e) {
94136       {
94137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94138       };
94139     } catch (std::exception& e) {
94140       {
94141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94142       };
94143     } catch (...) {
94144       {
94145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94146       };
94147     }
94148   }
94149 }
94150
94151
94152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94153   void * jresult ;
94154   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94155
94156   {
94157     try {
94158       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94159     } catch (std::out_of_range& e) {
94160       {
94161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94162       };
94163     } catch (std::exception& e) {
94164       {
94165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94166       };
94167     } catch (...) {
94168       {
94169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94170       };
94171     }
94172   }
94173   jresult = (void *)result;
94174   return jresult;
94175 }
94176
94177
94178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94179   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94180
94181   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94182   {
94183     try {
94184       delete arg1;
94185     } catch (std::out_of_range& e) {
94186       {
94187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94188       };
94189     } catch (std::exception& e) {
94190       {
94191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94192       };
94193     } catch (...) {
94194       {
94195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94196       };
94197     }
94198   }
94199 }
94200
94201 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94202     return (Dali::RefObject *)jarg1;
94203 }
94204
94205 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94206     return (Dali::SignalObserver *)jarg1;
94207 }
94208
94209 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94210     return (Dali::ConnectionTrackerInterface *)jarg1;
94211 }
94212
94213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94214     return (Dali::BaseHandle *)jarg1;
94215 }
94216
94217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94218     return (Dali::BaseHandle *)jarg1;
94219 }
94220
94221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94222     return (Dali::BaseHandle *)jarg1;
94223 }
94224
94225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94226     return (Dali::BaseHandle *)jarg1;
94227 }
94228
94229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94230     return (Dali::BaseHandle *)jarg1;
94231 }
94232
94233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94234     return (Dali::BaseHandle *)jarg1;
94235 }
94236
94237 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94238     return (Dali::BaseHandle *)jarg1;
94239 }
94240
94241 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94242     return (Dali::BaseHandle *)jarg1;
94243 }
94244
94245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94246     return (Dali::BaseHandle *)jarg1;
94247 }
94248
94249 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94250     return (Dali::BaseHandle *)jarg1;
94251 }
94252
94253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94254     return (Dali::BaseHandle *)jarg1;
94255 }
94256
94257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94258     return (Dali::BaseHandle *)jarg1;
94259 }
94260
94261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94262     return (Dali::BaseHandle *)jarg1;
94263 }
94264
94265 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94266     return (Dali::Handle *)jarg1;
94267 }
94268
94269 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94270     return (Dali::Handle *)jarg1;
94271 }
94272
94273 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94274     return (Dali::BaseHandle *)jarg1;
94275 }
94276
94277 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94278     return (Dali::BaseHandle *)jarg1;
94279 }
94280
94281 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94282     return (Dali::Handle *)jarg1;
94283 }
94284
94285 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94286     return (Dali::BaseHandle *)jarg1;
94287 }
94288
94289 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94290     return (Dali::Handle *)jarg1;
94291 }
94292
94293 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94294     return (Dali::GestureDetector *)jarg1;
94295 }
94296
94297 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94298     return (Dali::Gesture *)jarg1;
94299 }
94300
94301 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94302     return (Dali::Handle *)jarg1;
94303 }
94304
94305 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94306     return (Dali::Actor *)jarg1;
94307 }
94308
94309 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94310     return (Dali::BaseHandle *)jarg1;
94311 }
94312
94313 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94314     return (Dali::RefObject *)jarg1;
94315 }
94316
94317 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94318     return (Dali::Actor *)jarg1;
94319 }
94320
94321 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94322     return (Dali::GestureDetector *)jarg1;
94323 }
94324
94325 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94326     return (Dali::Gesture *)jarg1;
94327 }
94328
94329 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94330     return (Dali::GestureDetector *)jarg1;
94331 }
94332
94333 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94334     return (Dali::Gesture *)jarg1;
94335 }
94336
94337 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94338     return (Dali::GestureDetector *)jarg1;
94339 }
94340
94341 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94342     return (Dali::Gesture *)jarg1;
94343 }
94344
94345 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94346     return (Dali::BaseHandle *)jarg1;
94347 }
94348
94349 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94350     return (Dali::Handle *)jarg1;
94351 }
94352
94353 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94354     return (Dali::BaseHandle *)jarg1;
94355 }
94356
94357 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94358     return (Dali::Handle *)jarg1;
94359 }
94360
94361 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94362     return (Dali::Handle *)jarg1;
94363 }
94364
94365 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94366     return (Dali::Image *)jarg1;
94367 }
94368
94369 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94370     return (Dali::Image *)jarg1;
94371 }
94372
94373 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94374     return (Dali::Image *)jarg1;
94375 }
94376
94377 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94378     return (Dali::RefObject *)jarg1;
94379 }
94380
94381 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94382     return (Dali::Image *)jarg1;
94383 }
94384
94385 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94386     return (Dali::Image *)jarg1;
94387 }
94388
94389 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94390     return (Dali::ResourceImage *)jarg1;
94391 }
94392
94393 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94394     return (Dali::Actor *)jarg1;
94395 }
94396
94397 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94398     return (Dali::BaseHandle *)jarg1;
94399 }
94400
94401 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94402     return (Dali::BaseHandle *)jarg1;
94403 }
94404
94405 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94406     return (Dali::BaseHandle *)jarg1;
94407 }
94408
94409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94410     return (Dali::BaseHandle *)jarg1;
94411 }
94412
94413 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94414     return (Dali::BaseHandle *)jarg1;
94415 }
94416
94417 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94418     return (Dali::BaseHandle *)jarg1;
94419 }
94420
94421 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94422     return (Dali::CustomActorImpl *)jarg1;
94423 }
94424
94425 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94426     return (Dali::CustomActor *)jarg1;
94427 }
94428
94429 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94430     return (Dali::BaseHandle *)jarg1;
94431 }
94432
94433 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94434     return (Dali::Toolkit::Control *)jarg1;
94435 }
94436
94437 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94438     return (Dali::Toolkit::Control *)jarg1;
94439 }
94440
94441 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94442     return (Dali::Toolkit::Button *)jarg1;
94443 }
94444
94445 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94446     return (Dali::Toolkit::Button *)jarg1;
94447 }
94448
94449 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94450     return (Dali::Toolkit::Button *)jarg1;
94451 }
94452
94453 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94454     return (Dali::Toolkit::Control *)jarg1;
94455 }
94456
94457 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94458     return (Dali::Toolkit::Control *)jarg1;
94459 }
94460
94461 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94462     return (Dali::Toolkit::Control *)jarg1;
94463 }
94464
94465 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94466     return (Dali::Toolkit::Control *)jarg1;
94467 }
94468
94469 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94470     return (Dali::Toolkit::Control *)jarg1;
94471 }
94472
94473 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94474     return (Dali::RefObject *)jarg1;
94475 }
94476
94477 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94478     return (Dali::Toolkit::Scrollable *)jarg1;
94479 }
94480
94481 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94482     return (Dali::BaseHandle *)jarg1;
94483 }
94484
94485 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94486     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94487 }
94488
94489 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94490     return (Dali::RefObject *)jarg1;
94491 }
94492
94493 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94494     return (Dali::Toolkit::Ruler *)jarg1;
94495 }
94496
94497 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94498     return (Dali::Toolkit::Ruler *)jarg1;
94499 }
94500
94501 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94502     return (Dali::Toolkit::Scrollable *)jarg1;
94503 }
94504
94505 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94506     return (Dali::Toolkit::Control *)jarg1;
94507 }
94508
94509 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94510     return (Dali::Toolkit::Control *)jarg1;
94511 }
94512
94513 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94514     return (Dali::Toolkit::Control *)jarg1;
94515 }
94516
94517 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94518     return (Dali::Toolkit::Control *)jarg1;
94519 }
94520
94521 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94522     return (Dali::BaseHandle *)jarg1;
94523 }
94524
94525 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94526     return (Dali::BaseHandle *)jarg1;
94527 }
94528
94529 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94530     return (Dali::Toolkit::Control *)jarg1;
94531 }
94532
94533 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94534     return (Dali::Toolkit::Control *)jarg1;
94535 }
94536
94537 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94538     return (Dali::Toolkit::Control *)jarg1;
94539 }
94540
94541 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94542     return (Dali::Toolkit::Control *)jarg1;
94543 }
94544
94545 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94546     return (Dali::Toolkit::Control *)jarg1;
94547 }
94548
94549 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94550     return (Dali::Toolkit::Control *)jarg1;
94551 }
94552
94553 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94554     return (Dali::Toolkit::PageTurnView *)jarg1;
94555 }
94556
94557 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94558     return (Dali::Toolkit::PageTurnView *)jarg1;
94559 }
94560
94561 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94562     return (Dali::Toolkit::Button *)jarg1;
94563 }
94564
94565 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94566     return (Dali::BaseHandle *)jarg1;
94567 }
94568
94569 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94570     return (Dali::BaseHandle *)jarg1;
94571 }
94572
94573 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94574     return (Dali::BaseHandle *)jarg1;
94575 }
94576
94577
94578
94579
94580
94581 //////////////////////////////////////////////////
94582 //from dali-swig autogeneration (from dali_wrap.cpp)
94583
94584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94585   void * jresult ;
94586   Dali::ImfManager::ImfEventData *result = 0 ;
94587
94588   {
94589     try {
94590       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94591     } catch (std::out_of_range& e) {
94592       {
94593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94594       };
94595     } catch (std::exception& e) {
94596       {
94597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94598       };
94599     } catch (...) {
94600       {
94601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94602       };
94603     }
94604   }
94605   jresult = (void *)result;
94606   return jresult;
94607 }
94608
94609
94610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94611   void * jresult ;
94612   Dali::ImfManager::ImfEvent arg1 ;
94613   std::string *arg2 = 0 ;
94614   int arg3 ;
94615   int arg4 ;
94616   Dali::ImfManager::ImfEventData *result = 0 ;
94617
94618   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94619   if (!jarg2) {
94620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94621     return 0;
94622   }
94623   std::string arg2_str(jarg2);
94624   arg2 = &arg2_str;
94625   arg3 = (int)jarg3;
94626   arg4 = (int)jarg4;
94627   {
94628     try {
94629       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94630     } catch (std::out_of_range& e) {
94631       {
94632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94633       };
94634     } catch (std::exception& e) {
94635       {
94636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94637       };
94638     } catch (...) {
94639       {
94640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94641       };
94642     }
94643   }
94644   jresult = (void *)result;
94645
94646   //argout typemap for const std::string&
94647
94648   return jresult;
94649 }
94650
94651
94652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94653   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94654   std::string *arg2 = 0 ;
94655
94656   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94657   if (!jarg2) {
94658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94659     return ;
94660   }
94661   std::string arg2_str(jarg2);
94662   arg2 = &arg2_str;
94663   if (arg1) (arg1)->predictiveString = *arg2;
94664
94665   //argout typemap for const std::string&
94666
94667 }
94668
94669
94670 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94671   char * jresult ;
94672   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94673   std::string *result = 0 ;
94674
94675   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94676   result = (std::string *) & ((arg1)->predictiveString);
94677   jresult = SWIG_csharp_string_callback(result->c_str());
94678   return jresult;
94679 }
94680
94681
94682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94683   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94684   Dali::ImfManager::ImfEvent arg2 ;
94685
94686   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94687   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94688   if (arg1) (arg1)->eventName = arg2;
94689 }
94690
94691
94692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94693   int jresult ;
94694   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94695   Dali::ImfManager::ImfEvent result;
94696
94697   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94698   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94699   jresult = (int)result;
94700   return jresult;
94701 }
94702
94703
94704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_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)->cursorOffset = arg2;
94711 }
94712
94713
94714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_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)->cursorOffset);
94721   jresult = result;
94722   return jresult;
94723 }
94724
94725
94726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94727   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94728   int arg2 ;
94729
94730   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94731   arg2 = (int)jarg2;
94732   if (arg1) (arg1)->numberOfChars = arg2;
94733 }
94734
94735
94736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94737   int jresult ;
94738   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94739   int result;
94740
94741   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94742   result = (int) ((arg1)->numberOfChars);
94743   jresult = result;
94744   return jresult;
94745 }
94746
94747
94748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94749   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94750
94751   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94752   {
94753     try {
94754       delete arg1;
94755     } catch (std::out_of_range& e) {
94756       {
94757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94758       };
94759     } catch (std::exception& e) {
94760       {
94761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94762       };
94763     } catch (...) {
94764       {
94765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94766       };
94767     }
94768   }
94769 }
94770
94771
94772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94773   void * jresult ;
94774   Dali::ImfManager::ImfCallbackData *result = 0 ;
94775
94776   {
94777     try {
94778       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94779     } catch (std::out_of_range& e) {
94780       {
94781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94782       };
94783     } catch (std::exception& e) {
94784       {
94785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94786       };
94787     } catch (...) {
94788       {
94789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94790       };
94791     }
94792   }
94793   jresult = (void *)result;
94794   return jresult;
94795 }
94796
94797
94798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94799   void * jresult ;
94800   bool arg1 ;
94801   int arg2 ;
94802   std::string *arg3 = 0 ;
94803   bool arg4 ;
94804   Dali::ImfManager::ImfCallbackData *result = 0 ;
94805
94806   arg1 = jarg1 ? true : false;
94807   arg2 = (int)jarg2;
94808   if (!jarg3) {
94809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94810     return 0;
94811   }
94812   std::string arg3_str(jarg3);
94813   arg3 = &arg3_str;
94814   arg4 = jarg4 ? true : false;
94815   {
94816     try {
94817       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94818     } catch (std::out_of_range& e) {
94819       {
94820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94821       };
94822     } catch (std::exception& e) {
94823       {
94824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94825       };
94826     } catch (...) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94829       };
94830     }
94831   }
94832   jresult = (void *)result;
94833
94834   //argout typemap for const std::string&
94835
94836   return jresult;
94837 }
94838
94839
94840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94841   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94842   std::string *arg2 = 0 ;
94843
94844   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94845   if (!jarg2) {
94846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94847     return ;
94848   }
94849   std::string arg2_str(jarg2);
94850   arg2 = &arg2_str;
94851   if (arg1) (arg1)->currentText = *arg2;
94852
94853   //argout typemap for const std::string&
94854
94855 }
94856
94857
94858 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94859   char * jresult ;
94860   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94861   std::string *result = 0 ;
94862
94863   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94864   result = (std::string *) & ((arg1)->currentText);
94865   jresult = SWIG_csharp_string_callback(result->c_str());
94866   return jresult;
94867 }
94868
94869
94870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94871   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94872   int arg2 ;
94873
94874   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94875   arg2 = (int)jarg2;
94876   if (arg1) (arg1)->cursorPosition = arg2;
94877 }
94878
94879
94880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94881   int jresult ;
94882   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94883   int result;
94884
94885   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94886   result = (int) ((arg1)->cursorPosition);
94887   jresult = result;
94888   return jresult;
94889 }
94890
94891
94892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_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)->update = arg2;
94899 }
94900
94901
94902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_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)->update);
94909   jresult = result;
94910   return jresult;
94911 }
94912
94913
94914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94915   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94916   bool arg2 ;
94917
94918   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94919   arg2 = jarg2 ? true : false;
94920   if (arg1) (arg1)->preeditResetRequired = arg2;
94921 }
94922
94923
94924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94925   unsigned int jresult ;
94926   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94927   bool result;
94928
94929   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94930   result = (bool) ((arg1)->preeditResetRequired);
94931   jresult = result;
94932   return jresult;
94933 }
94934
94935
94936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94937   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94938
94939   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94940   {
94941     try {
94942       delete arg1;
94943     } catch (std::out_of_range& e) {
94944       {
94945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94946       };
94947     } catch (std::exception& e) {
94948       {
94949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94950       };
94951     } catch (...) {
94952       {
94953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94954       };
94955     }
94956   }
94957 }
94958
94959
94960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94961   void * jresult ;
94962   Dali::ImfManager result;
94963
94964   {
94965     try {
94966       result = Dali::ImfManager::Get();
94967     } catch (std::out_of_range& e) {
94968       {
94969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94970       };
94971     } catch (std::exception& e) {
94972       {
94973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94974       };
94975     } catch (...) {
94976       {
94977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94978       };
94979     }
94980   }
94981   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94982   return jresult;
94983 }
94984
94985
94986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94987   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94988
94989   arg1 = (Dali::ImfManager *)jarg1;
94990   {
94991     try {
94992       (arg1)->Activate();
94993     } catch (std::out_of_range& e) {
94994       {
94995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94996       };
94997     } catch (std::exception& e) {
94998       {
94999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95000       };
95001     } catch (...) {
95002       {
95003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95004       };
95005     }
95006   }
95007 }
95008
95009
95010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
95011   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95012
95013   arg1 = (Dali::ImfManager *)jarg1;
95014   {
95015     try {
95016       (arg1)->Deactivate();
95017     } catch (std::out_of_range& e) {
95018       {
95019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95020       };
95021     } catch (std::exception& e) {
95022       {
95023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95024       };
95025     } catch (...) {
95026       {
95027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95028       };
95029     }
95030   }
95031 }
95032
95033
95034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
95035   unsigned int jresult ;
95036   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95037   bool result;
95038
95039   arg1 = (Dali::ImfManager *)jarg1;
95040   {
95041     try {
95042       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
95043     } catch (std::out_of_range& e) {
95044       {
95045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95046       };
95047     } catch (std::exception& e) {
95048       {
95049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95050       };
95051     } catch (...) {
95052       {
95053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95054       };
95055     }
95056   }
95057   jresult = result;
95058   return jresult;
95059 }
95060
95061
95062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
95063   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95064   bool arg2 ;
95065
95066   arg1 = (Dali::ImfManager *)jarg1;
95067   arg2 = jarg2 ? true : false;
95068   {
95069     try {
95070       (arg1)->SetRestoreAfterFocusLost(arg2);
95071     } catch (std::out_of_range& e) {
95072       {
95073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95074       };
95075     } catch (std::exception& e) {
95076       {
95077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95078       };
95079     } catch (...) {
95080       {
95081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95082       };
95083     }
95084   }
95085 }
95086
95087
95088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
95089   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95090
95091   arg1 = (Dali::ImfManager *)jarg1;
95092   {
95093     try {
95094       (arg1)->Reset();
95095     } catch (std::out_of_range& e) {
95096       {
95097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95098       };
95099     } catch (std::exception& e) {
95100       {
95101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95102       };
95103     } catch (...) {
95104       {
95105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95106       };
95107     }
95108   }
95109 }
95110
95111
95112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
95113   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95114
95115   arg1 = (Dali::ImfManager *)jarg1;
95116   {
95117     try {
95118       (arg1)->NotifyCursorPosition();
95119     } catch (std::out_of_range& e) {
95120       {
95121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95122       };
95123     } catch (std::exception& e) {
95124       {
95125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95126       };
95127     } catch (...) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95130       };
95131     }
95132   }
95133 }
95134
95135
95136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95137   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95138   unsigned int arg2 ;
95139
95140   arg1 = (Dali::ImfManager *)jarg1;
95141   arg2 = (unsigned int)jarg2;
95142   {
95143     try {
95144       (arg1)->SetCursorPosition(arg2);
95145     } catch (std::out_of_range& e) {
95146       {
95147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95148       };
95149     } catch (std::exception& e) {
95150       {
95151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95152       };
95153     } catch (...) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95156       };
95157     }
95158   }
95159 }
95160
95161
95162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95163   unsigned int jresult ;
95164   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95165   unsigned int result;
95166
95167   arg1 = (Dali::ImfManager *)jarg1;
95168   {
95169     try {
95170       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95171     } catch (std::out_of_range& e) {
95172       {
95173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95174       };
95175     } catch (std::exception& e) {
95176       {
95177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95178       };
95179     } catch (...) {
95180       {
95181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95182       };
95183     }
95184   }
95185   jresult = result;
95186   return jresult;
95187 }
95188
95189
95190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95191   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95192   std::string *arg2 = 0 ;
95193
95194   arg1 = (Dali::ImfManager *)jarg1;
95195   if (!jarg2) {
95196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95197     return ;
95198   }
95199   std::string arg2_str(jarg2);
95200   arg2 = &arg2_str;
95201   {
95202     try {
95203       (arg1)->SetSurroundingText((std::string const &)*arg2);
95204     } catch (std::out_of_range& e) {
95205       {
95206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95207       };
95208     } catch (std::exception& e) {
95209       {
95210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95211       };
95212     } catch (...) {
95213       {
95214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95215       };
95216     }
95217   }
95218
95219   //argout typemap for const std::string&
95220
95221 }
95222
95223
95224 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95225   char * jresult ;
95226   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95227   std::string *result = 0 ;
95228
95229   arg1 = (Dali::ImfManager *)jarg1;
95230   {
95231     try {
95232       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95233     } catch (std::out_of_range& e) {
95234       {
95235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95236       };
95237     } catch (std::exception& e) {
95238       {
95239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95240       };
95241     } catch (...) {
95242       {
95243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95244       };
95245     }
95246   }
95247   jresult = SWIG_csharp_string_callback(result->c_str());
95248   return jresult;
95249 }
95250
95251
95252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95253   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95254   bool arg2 ;
95255
95256   arg1 = (Dali::ImfManager *)jarg1;
95257   arg2 = jarg2 ? true : false;
95258   {
95259     try {
95260       (arg1)->NotifyTextInputMultiLine(arg2);
95261     } catch (std::out_of_range& e) {
95262       {
95263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95264       };
95265     } catch (std::exception& e) {
95266       {
95267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95268       };
95269     } catch (...) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95272       };
95273     }
95274   }
95275 }
95276
95277
95278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95279   int jresult ;
95280   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95281   Dali::ImfManager::TextDirection result;
95282
95283   arg1 = (Dali::ImfManager *)jarg1;
95284   {
95285     try {
95286       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95287     } catch (std::out_of_range& e) {
95288       {
95289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95290       };
95291     } catch (std::exception& e) {
95292       {
95293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95294       };
95295     } catch (...) {
95296       {
95297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95298       };
95299     }
95300   }
95301   jresult = (int)result;
95302   return jresult;
95303 }
95304
95305
95306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95307   void * jresult ;
95308   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95309   Dali::Rect< int > result;
95310
95311   arg1 = (Dali::ImfManager *)jarg1;
95312   {
95313     try {
95314       result = (arg1)->GetInputMethodArea();
95315     } catch (std::out_of_range& e) {
95316       {
95317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95318       };
95319     } catch (std::exception& e) {
95320       {
95321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95322       };
95323     } catch (...) {
95324       {
95325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95326       };
95327     }
95328   }
95329   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95330   return jresult;
95331 }
95332
95333
95334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95335   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95336   Dali::InputMethodOptions *arg2 = 0 ;
95337
95338   arg1 = (Dali::ImfManager *)jarg1;
95339   arg2 = (Dali::InputMethodOptions *)jarg2;
95340   if (!arg2) {
95341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95342     return ;
95343   }
95344   {
95345     try {
95346       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95347     } catch (std::out_of_range& e) {
95348       {
95349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95350       };
95351     } catch (std::exception& e) {
95352       {
95353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95354       };
95355     } catch (...) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95358       };
95359     }
95360   }
95361 }
95362
95363
95364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95365   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95366   std::string *arg2 = 0 ;
95367
95368   arg1 = (Dali::ImfManager *)jarg1;
95369   if (!jarg2) {
95370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95371     return ;
95372   }
95373   std::string arg2_str(jarg2);
95374   arg2 = &arg2_str;
95375   {
95376     try {
95377       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95378     } catch (std::out_of_range& e) {
95379       {
95380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95381       };
95382     } catch (std::exception& e) {
95383       {
95384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95385       };
95386     } catch (...) {
95387       {
95388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95389       };
95390     }
95391   }
95392
95393   //argout typemap for const std::string&
95394
95395 }
95396
95397
95398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95399   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95400   std::string *arg2 = 0 ;
95401
95402   arg1 = (Dali::ImfManager *)jarg1;
95403   if (!jarg2) {
95404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95405     return ;
95406   }
95407   std::string arg2_str(jarg2);
95408   arg2 = &arg2_str;
95409   {
95410     try {
95411       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95412     } catch (std::out_of_range& e) {
95413       {
95414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95415       };
95416     } catch (std::exception& e) {
95417       {
95418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95419       };
95420     } catch (...) {
95421       {
95422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95423       };
95424     }
95425   }
95426
95427 }
95428
95429
95430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95431   int jresult ;
95432   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95433   Dali::ImfManager::State result;
95434
95435   arg1 = (Dali::ImfManager *)jarg1;
95436   {
95437     try {
95438       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95439     } catch (std::out_of_range& e) {
95440       {
95441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95442       };
95443     } catch (std::exception& e) {
95444       {
95445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95446       };
95447     } catch (...) {
95448       {
95449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95450       };
95451     }
95452   }
95453   jresult = (int)result;
95454   return jresult;
95455 }
95456
95457
95458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95459   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95460   bool arg2 ;
95461
95462   arg1 = (Dali::ImfManager *)jarg1;
95463   arg2 = jarg2 ? true : false;
95464   {
95465     try {
95466       (arg1)->SetReturnKeyState(arg2);
95467     } catch (std::out_of_range& e) {
95468       {
95469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (std::exception& e) {
95472       {
95473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (...) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95478       };
95479     }
95480   }
95481 }
95482
95483
95484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95485   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95486   bool arg2 ;
95487
95488   arg1 = (Dali::ImfManager *)jarg1;
95489   arg2 = jarg2 ? true : false;
95490   {
95491     try {
95492       (arg1)->AutoEnableInputPanel(arg2);
95493     } catch (std::out_of_range& e) {
95494       {
95495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95496       };
95497     } catch (std::exception& e) {
95498       {
95499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95500       };
95501     } catch (...) {
95502       {
95503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95504       };
95505     }
95506   }
95507 }
95508
95509
95510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95511   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95512
95513   arg1 = (Dali::ImfManager *)jarg1;
95514   {
95515     try {
95516       (arg1)->ShowInputPanel();
95517     } catch (std::out_of_range& e) {
95518       {
95519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95520       };
95521     } catch (std::exception& e) {
95522       {
95523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95524       };
95525     } catch (...) {
95526       {
95527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95528       };
95529     }
95530   }
95531 }
95532
95533
95534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95535   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95536
95537   arg1 = (Dali::ImfManager *)jarg1;
95538   {
95539     try {
95540       (arg1)->HideInputPanel();
95541     } catch (std::out_of_range& e) {
95542       {
95543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95544       };
95545     } catch (std::exception& e) {
95546       {
95547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95548       };
95549     } catch (...) {
95550       {
95551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95552       };
95553     }
95554   }
95555 }
95556
95557
95558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95559   void * jresult ;
95560   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95561   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95562
95563   arg1 = (Dali::ImfManager *)jarg1;
95564   {
95565     try {
95566       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95567     } catch (std::out_of_range& e) {
95568       {
95569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95570       };
95571     } catch (std::exception& e) {
95572       {
95573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95574       };
95575     } catch (...) {
95576       {
95577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95578       };
95579     }
95580   }
95581   jresult = (void *)result;
95582   return jresult;
95583 }
95584
95585
95586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95587   void * jresult ;
95588   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95589   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95590
95591   arg1 = (Dali::ImfManager *)jarg1;
95592   {
95593     try {
95594       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95595     } catch (std::out_of_range& e) {
95596       {
95597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95598       };
95599     } catch (std::exception& e) {
95600       {
95601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95602       };
95603     } catch (...) {
95604       {
95605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95606       };
95607     }
95608   }
95609   jresult = (void *)result;
95610   return jresult;
95611 }
95612
95613
95614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95615   void * jresult ;
95616   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95617   Dali::ImfManager::StatusSignalType *result = 0 ;
95618
95619   arg1 = (Dali::ImfManager *)jarg1;
95620   {
95621     try {
95622       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95623     } catch (std::out_of_range& e) {
95624       {
95625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95626       };
95627     } catch (std::exception& e) {
95628       {
95629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95630       };
95631     } catch (...) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95634       };
95635     }
95636   }
95637   jresult = (void *)result;
95638   return jresult;
95639 }
95640
95641
95642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95643   void * jresult ;
95644   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95645   Dali::ImfManager::VoidSignalType *result = 0 ;
95646
95647   arg1 = (Dali::ImfManager *)jarg1;
95648   {
95649     try {
95650       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95651     } catch (std::out_of_range& e) {
95652       {
95653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95654       };
95655     } catch (std::exception& e) {
95656       {
95657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95658       };
95659     } catch (...) {
95660       {
95661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95662       };
95663     }
95664   }
95665   jresult = (void *)result;
95666   return jresult;
95667 }
95668
95669
95670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95671   void * jresult ;
95672   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95673   Dali::ImfManager::VoidSignalType *result = 0 ;
95674
95675   arg1 = (Dali::ImfManager *)jarg1;
95676   {
95677     try {
95678       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95679     } catch (std::out_of_range& e) {
95680       {
95681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95682       };
95683     } catch (std::exception& e) {
95684       {
95685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (...) {
95688       {
95689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95690       };
95691     }
95692   }
95693   jresult = (void *)result;
95694   return jresult;
95695 }
95696
95697
95698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95699   void * jresult ;
95700   Dali::ImfManager *result = 0 ;
95701
95702   {
95703     try {
95704       result = (Dali::ImfManager *)new Dali::ImfManager();
95705     } catch (std::out_of_range& e) {
95706       {
95707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95708       };
95709     } catch (std::exception& e) {
95710       {
95711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95712       };
95713     } catch (...) {
95714       {
95715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95716       };
95717     }
95718   }
95719   jresult = (void *)result;
95720   return jresult;
95721 }
95722
95723
95724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95725   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95726
95727   arg1 = (Dali::ImfManager *)jarg1;
95728   {
95729     try {
95730       delete arg1;
95731     } catch (std::out_of_range& e) {
95732       {
95733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95734       };
95735     } catch (std::exception& e) {
95736       {
95737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95738       };
95739     } catch (...) {
95740       {
95741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95742       };
95743     }
95744   }
95745 }
95746
95747
95748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95749   void * jresult ;
95750   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95751   Dali::ImfManager *result = 0 ;
95752
95753   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95754   {
95755     try {
95756       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95757     } catch (std::out_of_range& e) {
95758       {
95759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95760       };
95761     } catch (std::exception& e) {
95762       {
95763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95764       };
95765     } catch (...) {
95766       {
95767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95768       };
95769     }
95770   }
95771   jresult = (void *)result;
95772   return jresult;
95773 }
95774
95775
95776 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95777     return (Dali::BaseHandle *)jarg1;
95778 }
95779
95780
95781 //////////////////////////////////////////////////
95782 //from dali-swig autogeneration (from dali_wrap.cpp)
95783
95784
95785
95786
95787
95788
95789
95790
95791
95792
95793
95794
95795 #ifdef __cplusplus
95796 }
95797 #endif
95798