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
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/window.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441 #include <dali/devel-api/adaptor-framework/window-devel.h>
 442
 443 #include <dali/devel-api/images/nine-patch-image.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/control-devel.h>
 451 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 452 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 459 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 460
 461 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 462 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 463 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 464
 465 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469
 470 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 471
 472 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 473
 474
 475 // add here SWIG version check
 476
 477 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 478 // disable Swig-dependent warnings
 479
 480 // 'identifier1' has C-linkage specified,
 481 // but returns UDT 'identifier2' which is incompatible with C
 482 #pragma warning(disable: 4190)
 483
 484 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 485 #pragma warning(disable: 4800)
 486
 487 // debug info too long etc etc
 488 #pragma warning(disable: 4786)
 489 #endif
 490
 491
 492 #include <stdexcept>
 493
 494
 495 #include <string>
 496
 497
 498 #include <vector>
 499 #include <algorithm>
 500 #include <stdexcept>
 501
 502
 503 #include <map>
 504 #include <algorithm>
 505 #include <stdexcept>
 506
 507
 508 #include <utility>
 509
 510
 511 typedef float floatp;
 512
 513 SWIGINTERN floatp *new_floatp(){
 514   return new float();
 515 }
 516 SWIGINTERN void delete_floatp(floatp *self){
 517   if (self) delete self;
 518 }
 519 SWIGINTERN void floatp_assign(floatp *self,float value){
 520   *self = value;
 521 }
 522 SWIGINTERN float floatp_value(floatp *self){
 523   return *self;
 524 }
 525 SWIGINTERN float *floatp_cast(floatp *self){
 526   return self;
 527 }
 528 SWIGINTERN floatp *floatp_frompointer(float *t){
 529   return (floatp *) t;
 530 }
 531
 532 typedef int intp;
 533
 534 SWIGINTERN intp *new_intp(){
 535   return new int();
 536 }
 537 SWIGINTERN void delete_intp(intp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void intp_assign(intp *self,int value){
 541   *self = value;
 542 }
 543 SWIGINTERN int intp_value(intp *self){
 544   return *self;
 545 }
 546 SWIGINTERN int *intp_cast(intp *self){
 547   return self;
 548 }
 549 SWIGINTERN intp *intp_frompointer(int *t){
 550   return (intp *) t;
 551 }
 552
 553 typedef double doublep;
 554
 555 SWIGINTERN doublep *new_doublep(){
 556   return new double();
 557 }
 558 SWIGINTERN void delete_doublep(doublep *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void doublep_assign(doublep *self,double value){
 562   *self = value;
 563 }
 564 SWIGINTERN double doublep_value(doublep *self){
 565   return *self;
 566 }
 567 SWIGINTERN double *doublep_cast(doublep *self){
 568   return self;
 569 }
 570 SWIGINTERN doublep *doublep_frompointer(double *t){
 571   return (doublep *) t;
 572 }
 573
 574 typedef unsigned int uintp;
 575
 576 SWIGINTERN uintp *new_uintp(){
 577   return new unsigned int();
 578 }
 579 SWIGINTERN void delete_uintp(uintp *self){
 580   if (self) delete self;
 581 }
 582 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 583   *self = value;
 584 }
 585 SWIGINTERN unsigned int uintp_value(uintp *self){
 586   return *self;
 587 }
 588 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 589   return self;
 590 }
 591 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 592   return (uintp *) t;
 593 }
 594
 595 typedef unsigned short ushortp;
 596
 597 SWIGINTERN ushortp *new_ushortp(){
 598   return new unsigned short();
 599 }
 600 SWIGINTERN void delete_ushortp(ushortp *self){
 601   if (self) delete self;
 602 }
 603 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 604   *self = value;
 605 }
 606 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 607   return *self;
 608 }
 609 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 610   return self;
 611 }
 612 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 613   return (ushortp *) t;
 614 }
 615
 616 unsigned int int_to_uint(int x) {
 617    return (unsigned int) x;
 618 }
 619
 620
 621 using namespace Dali;
 622 using namespace Dali::Toolkit;
 623
 624 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 625
 626      // C++ code. DALi uses Handle <-> Body design pattern.
 627      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 628      // Handles in DALi can be converted into a boolean type
 629      // to check if the handle has a valid body attached to it.
 630      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 631      if( *self )
 632      {
 633        return true;
 634      }
 635      else
 636      {
 637        return false;
 638      }
 639     }
 640 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 641
 642      // C++ code. Check if two handles reference the same implemtion
 643      if( *self == rhs)
 644      {
 645        return true;
 646      }
 647      else
 648      {
 649        return false;
 650      }
 651     }
 652 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 653      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 654    }
 655 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){
 656      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 657    }
 658 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 659         std::vector< Dali::TouchPoint >* pv = 0;
 660         if (capacity >= 0) {
 661           pv = new std::vector< Dali::TouchPoint >();
 662           pv->reserve(capacity);
 663        } else {
 664           throw std::out_of_range("capacity");
 665        }
 666        return pv;
 667       }
 668 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 669         if (index>=0 && index<(int)self->size())
 670           return (*self)[index];
 671         else
 672           throw std::out_of_range("index");
 673       }
 674 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 675         if (index>=0 && index<(int)self->size())
 676           return (*self)[index];
 677         else
 678           throw std::out_of_range("index");
 679       }
 680 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 681         if (index>=0 && index<(int)self->size())
 682           (*self)[index] = val;
 683         else
 684           throw std::out_of_range("index");
 685       }
 686 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 687         self->insert(self->end(), values.begin(), values.end());
 688       }
 689 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 690         if (index < 0)
 691           throw std::out_of_range("index");
 692         if (count < 0)
 693           throw std::out_of_range("count");
 694         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 695           throw std::invalid_argument("invalid range");
 696         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 697       }
 698 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 699         if (index>=0 && index<(int)self->size()+1)
 700           self->insert(self->begin()+index, x);
 701         else
 702           throw std::out_of_range("index");
 703       }
 704 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 705         if (index>=0 && index<(int)self->size()+1)
 706           self->insert(self->begin()+index, values.begin(), values.end());
 707         else
 708           throw std::out_of_range("index");
 709       }
 710 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 711         if (index>=0 && index<(int)self->size())
 712           self->erase(self->begin() + index);
 713         else
 714           throw std::out_of_range("index");
 715       }
 716 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 717         if (index < 0)
 718           throw std::out_of_range("index");
 719         if (count < 0)
 720           throw std::out_of_range("count");
 721         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 722           throw std::invalid_argument("invalid range");
 723         self->erase(self->begin()+index, self->begin()+index+count);
 724       }
 725 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 726         if (count < 0)
 727           throw std::out_of_range("count");
 728         return new std::vector< Dali::TouchPoint >(count, value);
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 731         std::reverse(self->begin(), self->end());
 732       }
 733 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 734         if (index < 0)
 735           throw std::out_of_range("index");
 736         if (count < 0)
 737           throw std::out_of_range("count");
 738         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 739           throw std::invalid_argument("invalid range");
 740         std::reverse(self->begin()+index, self->begin()+index+count);
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 743         if (index < 0)
 744           throw std::out_of_range("index");
 745         if (index+values.size() > self->size())
 746           throw std::out_of_range("index");
 747         std::copy(values.begin(), values.end(), self->begin()+index);
 748       }
 749 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 750          return self->Empty();
 751       }
 752 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 753         return self->GetConnectionCount();
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 756           self->Connect( func );
 757       }
 758 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 759           self->Disconnect( func );
 760       }
 761 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 762           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 763 /*@SWIG@*/ self->Emit( arg );
 764       }
 765 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 766          return self->Empty();
 767       }
 768 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 769         return self->GetConnectionCount();
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 772           self->Connect( func );
 773       }
 774 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 775           self->Disconnect( func );
 776       }
 777 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 778           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 779 /*@SWIG@*/ self->Emit( arg );
 780       }
 781 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 782          return self->Empty();
 783       }
 784 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){
 785         return self->GetConnectionCount();
 786       }
 787 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 *)){
 788           self->Connect( func );
 789       }
 790 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 *)){
 791           self->Disconnect( func );
 792       }
 793 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){
 794           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 795 /*@SWIG@*/ self->Emit( arg );
 796       }
 797 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 798          return self->Empty();
 799       }
 800 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 801         return self->GetConnectionCount();
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 804           self->Connect( func );
 805       }
 806 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 807           self->Disconnect( func );
 808       }
 809 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 810           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 811 /*@SWIG@*/ self->Emit( arg );
 812       }
 813 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 814          return self->Empty();
 815       }
 816 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 817         return self->GetConnectionCount();
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 820           self->Connect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 823           self->Disconnect( func );
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 826           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 827 /*@SWIG@*/ self->Emit( arg );
 828       }
 829 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){
 830          return self->Empty();
 831       }
 832 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){
 833         return self->GetConnectionCount();
 834       }
 835 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 &)){
 836         self->Connect( func );
 837       }
 838 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 &)){
 839         self->Disconnect( func );
 840       }
 841 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){
 842         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 843 /*@SWIG@*/ self->Emit( arg1, arg2 );
 844       }
 845 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){
 846          return self->Empty();
 847       }
 848 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){
 849         return self->GetConnectionCount();
 850       }
 851 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 &)){
 852         self->Connect( func );
 853       }
 854 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 &)){
 855         self->Disconnect( func );
 856       }
 857 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){
 858         return self->Emit( arg1, arg2 );
 859       }
 860 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){
 861          return self->Empty();
 862       }
 863 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){
 864         return self->GetConnectionCount();
 865       }
 866 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 &)){
 867         self->Connect( func );
 868       }
 869 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 &)){
 870         self->Disconnect( func );
 871       }
 872 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){
 873         return self->Emit( arg1, arg2 );
 874       }
 875 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){
 876          return self->Empty();
 877       }
 878 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){
 879         return self->GetConnectionCount();
 880       }
 881 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 &)){
 882         self->Connect( func );
 883       }
 884 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 &)){
 885         self->Disconnect( func );
 886       }
 887 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){
 888         return self->Emit( arg1, arg2 );
 889       }
 890 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 891          return self->Empty();
 892       }
 893 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 894         return self->GetConnectionCount();
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 897           self->Connect( func );
 898       }
 899 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 900           self->Disconnect( func );
 901       }
 902 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 903           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 904 /*@SWIG@*/ self->Emit( arg );
 905       }
 906 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 907          return self->Empty();
 908       }
 909 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){
 910         return self->GetConnectionCount();
 911       }
 912 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 &)){
 913           self->Connect( func );
 914       }
 915 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 &)){
 916           self->Disconnect( func );
 917       }
 918 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){
 919           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 920 /*@SWIG@*/ self->Emit( arg );
 921       }
 922 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 923          return self->Empty();
 924       }
 925 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){
 926         return self->GetConnectionCount();
 927       }
 928 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 &)){
 929           self->Connect( func );
 930       }
 931 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 &)){
 932           self->Disconnect( func );
 933       }
 934 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){
 935           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 936 /*@SWIG@*/ self->Emit( arg );
 937       }
 938 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 939          return self->Empty();
 940       }
 941 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){
 942         return self->GetConnectionCount();
 943       }
 944 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 &)){
 945           self->Connect( func );
 946       }
 947 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 &)){
 948           self->Disconnect( func );
 949       }
 950 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){
 951           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 952 /*@SWIG@*/ self->Emit( arg );
 953       }
 954 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){
 955          return self->Empty();
 956       }
 957 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){
 958         return self->GetConnectionCount();
 959       }
 960 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 &)){
 961         self->Connect( func );
 962       }
 963 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 &)){
 964         self->Disconnect( func );
 965       }
 966 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){
 967         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 968 /*@SWIG@*/ self->Emit( arg1, arg2 );
 969       }
 970 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){
 971          return self->Empty();
 972       }
 973 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){
 974         return self->GetConnectionCount();
 975       }
 976 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 &)){
 977         self->Connect( func );
 978       }
 979 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 &)){
 980         self->Disconnect( func );
 981       }
 982 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){
 983         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 984 /*@SWIG@*/ self->Emit( arg1, arg2 );
 985       }
 986 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){
 987          return self->Empty();
 988       }
 989 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){
 990         return self->GetConnectionCount();
 991       }
 992 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 &)){
 993         self->Connect( func );
 994       }
 995 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 &)){
 996         self->Disconnect( func );
 997       }
 998 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){
 999         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1000 /*@SWIG@*/ self->Emit( arg1, arg2 );
1001       }
1002 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1003          return self->Empty();
1004       }
1005 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1006         return self->GetConnectionCount();
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1009           self->Connect( func );
1010       }
1011 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1012           self->Disconnect( func );
1013       }
1014 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1015           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1016 /*@SWIG@*/ self->Emit( arg );
1017       }
1018 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1019          return self->Empty();
1020       }
1021 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1022         return self->GetConnectionCount();
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1025           self->Connect( func );
1026       }
1027 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1028           self->Disconnect( func );
1029       }
1030 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1031           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1032 /*@SWIG@*/ self->Emit( arg );
1033       }
1034 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){
1035          return self->Empty();
1036       }
1037 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){
1038         return self->GetConnectionCount();
1039       }
1040 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)){
1041           return self->Connect( func );
1042       }
1043 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)){
1044           self->Disconnect( func );
1045       }
1046 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){
1047           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1048 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1049       }
1050
1051   // keep argcs and argv so they're always available to DALi
1052   int argC = 1;
1053   char **argV = NULL;
1054
1055 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1056          return self->Empty();
1057       }
1058 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1059         return self->GetConnectionCount();
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1062           self->Connect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1065           self->Disconnect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1068           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1069 /*@SWIG@*/ self->Emit( arg );
1070       }
1071 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1072          return self->Empty();
1073       }
1074 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){
1075         return self->GetConnectionCount();
1076       }
1077 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 *)){
1078         self->Connect( func );
1079       }
1080 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 *)){
1081         self->Disconnect( func );
1082       }
1083 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){
1084         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1085 /*@SWIG@*/ self->Emit( arg1, arg2 );
1086       }
1087 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1088          return self->Empty();
1089       }
1090 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1091         return self->GetConnectionCount();
1092       }
1093 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1094           self->Connect( func );
1095       }
1096 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1097           self->Disconnect( func );
1098       }
1099 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1100           return self->Emit();
1101       }
1102 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1103          return self->Empty();
1104       }
1105 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1106         return self->GetConnectionCount();
1107       }
1108 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1109           self->Connect( func );
1110       }
1111 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1112           self->Disconnect( func );
1113       }
1114 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1115           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1116 /*@SWIG@*/ self->Emit( arg );
1117       }
1118 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1119         std::vector< unsigned int >* pv = 0;
1120         if (capacity >= 0) {
1121           pv = new std::vector< unsigned int >();
1122           pv->reserve(capacity);
1123        } else {
1124           throw std::out_of_range("capacity");
1125        }
1126        return pv;
1127       }
1128 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1135         if (index>=0 && index<(int)self->size())
1136           return (*self)[index];
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1141         if (index>=0 && index<(int)self->size())
1142           (*self)[index] = val;
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1147         self->insert(self->end(), values.begin(), values.end());
1148       }
1149 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1150         if (index < 0)
1151           throw std::out_of_range("index");
1152         if (count < 0)
1153           throw std::out_of_range("count");
1154         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1155           throw std::invalid_argument("invalid range");
1156         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, x);
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1165         if (index>=0 && index<(int)self->size()+1)
1166           self->insert(self->begin()+index, values.begin(), values.end());
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1171         if (index>=0 && index<(int)self->size())
1172           self->erase(self->begin() + index);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1177         if (index < 0)
1178           throw std::out_of_range("index");
1179         if (count < 0)
1180           throw std::out_of_range("count");
1181         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1182           throw std::invalid_argument("invalid range");
1183         self->erase(self->begin()+index, self->begin()+index+count);
1184       }
1185 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         return new std::vector< unsigned int >(count, value);
1189       }
1190 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1191         std::reverse(self->begin(), self->end());
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1194         if (index < 0)
1195           throw std::out_of_range("index");
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1199           throw std::invalid_argument("invalid range");
1200         std::reverse(self->begin()+index, self->begin()+index+count);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1203         if (index < 0)
1204           throw std::out_of_range("index");
1205         if (index+values.size() > self->size())
1206           throw std::out_of_range("index");
1207         std::copy(values.begin(), values.end(), self->begin()+index);
1208       }
1209 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1210         return std::find(self->begin(), self->end(), value) != self->end();
1211       }
1212 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1213         int index = -1;
1214         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1215         if (it != self->end())
1216           index = (int)(it - self->begin());
1217         return index;
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1222         if (rit != self->rend())
1223           index = (int)(self->rend() - 1 - rit);
1224         return index;
1225       }
1226 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1227         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1228         if (it != self->end()) {
1229           self->erase(it);
1230           return true;
1231         }
1232         return false;
1233       }
1234 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){
1235         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1236         if (capacity >= 0) {
1237           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1238           pv->reserve(capacity);
1239        } else {
1240           throw std::out_of_range("capacity");
1241        }
1242        return pv;
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           return (*self)[index];
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         if (index>=0 && index<(int)self->size())
1258           (*self)[index] = val;
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 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){
1263         self->insert(self->end(), values.begin(), values.end());
1264       }
1265 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){
1266         if (index < 0)
1267           throw std::out_of_range("index");
1268         if (count < 0)
1269           throw std::out_of_range("count");
1270         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1271           throw std::invalid_argument("invalid range");
1272         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, x);
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size()+1)
1282           self->insert(self->begin()+index, values.begin(), values.end());
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 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){
1287         if (index>=0 && index<(int)self->size())
1288           self->erase(self->begin() + index);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 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){
1293         if (index < 0)
1294           throw std::out_of_range("index");
1295         if (count < 0)
1296           throw std::out_of_range("count");
1297         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1298           throw std::invalid_argument("invalid range");
1299         self->erase(self->begin()+index, self->begin()+index+count);
1300       }
1301 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){
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1305       }
1306 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){
1307         std::reverse(self->begin(), self->end());
1308       }
1309 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){
1310         if (index < 0)
1311           throw std::out_of_range("index");
1312         if (count < 0)
1313           throw std::out_of_range("count");
1314         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1315           throw std::invalid_argument("invalid range");
1316         std::reverse(self->begin()+index, self->begin()+index+count);
1317       }
1318 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){
1319         if (index < 0)
1320           throw std::out_of_range("index");
1321         if (index+values.size() > self->size())
1322           throw std::out_of_range("index");
1323         std::copy(values.begin(), values.end(), self->begin()+index);
1324       }
1325 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1326         std::vector< Dali::Actor >* pv = 0;
1327         if (capacity >= 0) {
1328           pv = new std::vector< Dali::Actor >();
1329           pv->reserve(capacity);
1330        } else {
1331           throw std::out_of_range("capacity");
1332        }
1333        return pv;
1334       }
1335 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1342         if (index>=0 && index<(int)self->size())
1343           return (*self)[index];
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1348         if (index>=0 && index<(int)self->size())
1349           (*self)[index] = val;
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1354         self->insert(self->end(), values.begin(), values.end());
1355       }
1356 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1357         if (index < 0)
1358           throw std::out_of_range("index");
1359         if (count < 0)
1360           throw std::out_of_range("count");
1361         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1362           throw std::invalid_argument("invalid range");
1363         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, x);
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1372         if (index>=0 && index<(int)self->size()+1)
1373           self->insert(self->begin()+index, values.begin(), values.end());
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1378         if (index>=0 && index<(int)self->size())
1379           self->erase(self->begin() + index);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1384         if (index < 0)
1385           throw std::out_of_range("index");
1386         if (count < 0)
1387           throw std::out_of_range("count");
1388         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1389           throw std::invalid_argument("invalid range");
1390         self->erase(self->begin()+index, self->begin()+index+count);
1391       }
1392 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         return new std::vector< Dali::Actor >(count, value);
1396       }
1397 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1398         std::reverse(self->begin(), self->end());
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1401         if (index < 0)
1402           throw std::out_of_range("index");
1403         if (count < 0)
1404           throw std::out_of_range("count");
1405         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1406           throw std::invalid_argument("invalid range");
1407         std::reverse(self->begin()+index, self->begin()+index+count);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1410         if (index < 0)
1411           throw std::out_of_range("index");
1412         if (index+values.size() > self->size())
1413           throw std::out_of_range("index");
1414         std::copy(values.begin(), values.end(), self->begin()+index);
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 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 &)){
1423           self->Connect( func );
1424       }
1425 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 &)){
1426           self->Disconnect( func );
1427       }
1428 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){
1429           return self->Emit( arg );
1430       }
1431 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){
1432          return self->Empty();
1433       }
1434 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){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438         self->Connect( func );
1439       }
1440 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)){
1441         self->Disconnect( func );
1442       }
1443 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){
1444         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg1, arg2 );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1448          return self->Empty();
1449       }
1450 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){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454         self->Connect( func );
1455       }
1456 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)){
1457         self->Disconnect( func );
1458       }
1459 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){
1460         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470         self->Connect( func );
1471       }
1472 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)){
1473         self->Disconnect( func );
1474       }
1475 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){
1476         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg1, arg2 );
1478       }
1479 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){
1480          return self->Empty();
1481       }
1482 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){
1483         return self->GetConnectionCount();
1484       }
1485 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)){
1486         self->Connect( func );
1487       }
1488 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)){
1489         self->Disconnect( func );
1490       }
1491 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){
1492         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg1, arg2 );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1496          return self->Empty();
1497       }
1498 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1499         return self->GetConnectionCount();
1500       }
1501 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)){
1502           self->Connect( func );
1503       }
1504 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)){
1505           self->Disconnect( func );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1508           return self->Emit( arg );
1509       }
1510 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1511          return self->Empty();
1512       }
1513 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1514         return self->GetConnectionCount();
1515       }
1516 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)){
1517           self->Connect( func );
1518       }
1519 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)){
1520           self->Disconnect( func );
1521       }
1522 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1523           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1524 /*@SWIG@*/ self->Emit( arg );
1525       }
1526 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){
1527          return self->Empty();
1528       }
1529 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){
1530         return self->GetConnectionCount();
1531       }
1532 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)){
1533           return self->Connect( func );
1534       }
1535 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)){
1536           self->Disconnect( func );
1537       }
1538 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){
1539           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1540 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1541       }
1542 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1543          return self->Empty();
1544       }
1545 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1546         return self->GetConnectionCount();
1547       }
1548 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)){
1549           self->Connect( func );
1550       }
1551 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)){
1552           self->Disconnect( func );
1553       }
1554 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1555           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1556 /*@SWIG@*/ self->Emit( arg );
1557       }
1558 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){
1559          return self->Empty();
1560       }
1561 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){
1562         return self->GetConnectionCount();
1563       }
1564 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)){
1565           return self->Connect( func );
1566       }
1567 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)){
1568           self->Disconnect( func );
1569       }
1570 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){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1573       }
1574 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){
1575          return self->Empty();
1576       }
1577 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){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1591          return self->Empty();
1592       }
1593 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){
1594         return self->GetConnectionCount();
1595       }
1596 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 &)){
1597           self->Connect( func );
1598       }
1599 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 &)){
1600           self->Disconnect( func );
1601       }
1602 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){
1603           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1604 /*@SWIG@*/ self->Emit( arg );
1605       }
1606 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1607          return self->Empty();
1608       }
1609 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1610         return self->GetConnectionCount();
1611       }
1612 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)){
1613           self->Connect( func );
1614       }
1615 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)){
1616           self->Disconnect( func );
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1619           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1620 /*@SWIG@*/ self->Emit( arg );
1621       }
1622 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1623          return self->Empty();
1624       }
1625 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1626         return self->GetConnectionCount();
1627       }
1628 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)){
1629           self->Connect( func );
1630       }
1631 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)){
1632           self->Disconnect( func );
1633       }
1634 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1635           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1636 /*@SWIG@*/ self->Emit( arg );
1637       }
1638 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){
1639          return self->Empty();
1640       }
1641 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){
1642         return self->GetConnectionCount();
1643       }
1644 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 &)){
1645         self->Connect( func );
1646       }
1647 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 &)){
1648         self->Disconnect( func );
1649       }
1650 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){
1651         return self->Emit( arg1, arg2 );
1652       }
1653 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1654          return self->Empty();
1655       }
1656 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1657         return self->GetConnectionCount();
1658       }
1659 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)){
1660           self->Connect( func );
1661       }
1662 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)){
1663           self->Disconnect( func );
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1666           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1667 /*@SWIG@*/ self->Emit( arg );
1668       }
1669 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1670          return self->Empty();
1671       }
1672 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1673         return self->GetConnectionCount();
1674       }
1675 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 &)){
1676           self->Connect( func );
1677       }
1678 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 &)){
1679           self->Disconnect( func );
1680       }
1681 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){
1682           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1683 /*@SWIG@*/ self->Emit( arg );
1684       }
1685 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1686          return self->Empty();
1687       }
1688 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){
1689         return self->GetConnectionCount();
1690       }
1691 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)){
1692         self->Connect( func );
1693       }
1694 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)){
1695         self->Disconnect( func );
1696       }
1697 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){
1698         return self->Emit( arg1, arg2 );
1699       }
1700 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1701          return self->Empty();
1702       }
1703 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){
1704         return self->GetConnectionCount();
1705       }
1706 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)){
1707         self->Connect( func );
1708       }
1709 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)){
1710         self->Disconnect( func );
1711       }
1712 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){
1713         return self->Emit( arg1, arg2 );
1714       }
1715
1716
1717 /* ---------------------------------------------------
1718  * C++ director class methods
1719  * --------------------------------------------------- */
1720
1721 #include "dali_wrap.h"
1722
1723 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1724   swig_init_callbacks();
1725 }
1726
1727 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1728
1729 }
1730
1731
1732 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1733   int jdepth  ;
1734
1735   if (!swig_callbackOnStageConnection) {
1736     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1737     return;
1738   } else {
1739     jdepth = depth;
1740     swig_callbackOnStageConnection(jdepth);
1741   }
1742 }
1743
1744 void SwigDirector_ViewImpl::OnStageDisconnection() {
1745   if (!swig_callbackOnStageDisconnection) {
1746     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1747     return;
1748   } else {
1749     swig_callbackOnStageDisconnection();
1750   }
1751 }
1752
1753 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1754   void * jchild = 0 ;
1755
1756   if (!swig_callbackOnChildAdd) {
1757     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1758     return;
1759   } else {
1760     jchild = (Dali::Actor *) &child;
1761     swig_callbackOnChildAdd(jchild);
1762   }
1763 }
1764
1765 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1766   void * jchild = 0 ;
1767
1768   if (!swig_callbackOnChildRemove) {
1769     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1770     return;
1771   } else {
1772     jchild = (Dali::Actor *) &child;
1773     swig_callbackOnChildRemove(jchild);
1774   }
1775 }
1776
1777 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1778   int jindex  ;
1779   void * jpropertyValue  ;
1780
1781   if (!swig_callbackOnPropertySet) {
1782     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1783     return;
1784   } else {
1785     jindex = index;
1786     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1787     swig_callbackOnPropertySet(jindex, jpropertyValue);
1788   }
1789 }
1790
1791 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1792   void * jtargetSize = 0 ;
1793
1794   if (!swig_callbackOnSizeSet) {
1795     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1796     return;
1797   } else {
1798     jtargetSize = (Dali::Vector3 *) &targetSize;
1799     swig_callbackOnSizeSet(jtargetSize);
1800   }
1801 }
1802
1803 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1804   void * janimation = 0 ;
1805   void * jtargetSize = 0 ;
1806
1807   if (!swig_callbackOnSizeAnimation) {
1808     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1809     return;
1810   } else {
1811     janimation = (Dali::Animation *) &animation;
1812     jtargetSize = (Dali::Vector3 *) &targetSize;
1813     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1814   }
1815 }
1816
1817 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1818   bool c_result = SwigValueInit< bool >() ;
1819   unsigned int jresult = 0 ;
1820   void * jarg0 = 0 ;
1821
1822   if (!swig_callbackOnTouchEvent) {
1823     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1824   } else {
1825     jarg0 = (Dali::TouchEvent *) &event;
1826     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1827     c_result = jresult ? true : false;
1828   }
1829   return c_result;
1830 }
1831
1832 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1833   bool c_result = SwigValueInit< bool >() ;
1834   unsigned int jresult = 0 ;
1835   void * jarg0 = 0 ;
1836
1837   if (!swig_callbackOnHoverEvent) {
1838     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1839   } else {
1840     jarg0 = (Dali::HoverEvent *) &event;
1841     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1842     c_result = jresult ? true : false;
1843   }
1844   return c_result;
1845 }
1846
1847 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1848   bool c_result = SwigValueInit< bool >() ;
1849   unsigned int jresult = 0 ;
1850   void * jarg0 = 0 ;
1851
1852   if (!swig_callbackOnKeyEvent) {
1853     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1854   } else {
1855     jarg0 = (Dali::KeyEvent *) &event;
1856     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1857     c_result = jresult ? true : false;
1858   }
1859   return c_result;
1860 }
1861
1862 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1863   bool c_result = SwigValueInit< bool >() ;
1864   unsigned int jresult = 0 ;
1865   void * jarg0 = 0 ;
1866
1867   if (!swig_callbackOnWheelEvent) {
1868     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1869   } else {
1870     jarg0 = (Dali::WheelEvent *) &event;
1871     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1872     c_result = jresult ? true : false;
1873   }
1874   return c_result;
1875 }
1876
1877 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1878   void * jsize = 0 ;
1879   void * jcontainer = 0 ;
1880
1881   if (!swig_callbackOnRelayout) {
1882     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1883     return;
1884   } else {
1885     jsize = (Dali::Vector2 *) &size;
1886     jcontainer = (Dali::RelayoutContainer *) &container;
1887     swig_callbackOnRelayout(jsize, jcontainer);
1888   }
1889 }
1890
1891 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1892   int jpolicy  ;
1893   int jdimension  ;
1894
1895   if (!swig_callbackOnSetResizePolicy) {
1896     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1897     return;
1898   } else {
1899     jpolicy = (int)policy;
1900     jdimension = (int)dimension;
1901     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1902   }
1903 }
1904
1905 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1906   Dali::Vector3 c_result ;
1907   void * jresult = 0 ;
1908
1909   if (!swig_callbackGetNaturalSize) {
1910     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1911   } else {
1912     jresult = (void *) swig_callbackGetNaturalSize();
1913     if (!jresult) {
1914       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1915       return c_result;
1916     }
1917     c_result = *(Dali::Vector3 *)jresult;
1918   }
1919   return c_result;
1920 }
1921
1922 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1923   float c_result = SwigValueInit< float >() ;
1924   float jresult = 0 ;
1925   void * jchild = 0 ;
1926   int jdimension  ;
1927
1928   if (!swig_callbackCalculateChildSize) {
1929     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1930   } else {
1931     jchild = (Dali::Actor *) &child;
1932     jdimension = (int)dimension;
1933     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1934     c_result = (float)jresult;
1935   }
1936   return c_result;
1937 }
1938
1939 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1940   float c_result = SwigValueInit< float >() ;
1941   float jresult = 0 ;
1942   float jwidth  ;
1943
1944   if (!swig_callbackGetHeightForWidth) {
1945     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1946   } else {
1947     jwidth = width;
1948     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1949     c_result = (float)jresult;
1950   }
1951   return c_result;
1952 }
1953
1954 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1955   float c_result = SwigValueInit< float >() ;
1956   float jresult = 0 ;
1957   float jheight  ;
1958
1959   if (!swig_callbackGetWidthForHeight) {
1960     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1961   } else {
1962     jheight = height;
1963     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1964     c_result = (float)jresult;
1965   }
1966   return c_result;
1967 }
1968
1969 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1970   bool c_result = SwigValueInit< bool >() ;
1971   unsigned int jresult = 0 ;
1972   int jdimension  ;
1973
1974   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1975     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1976   } else {
1977     jdimension = (int)dimension;
1978     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1979     c_result = jresult ? true : false;
1980   }
1981   return c_result;
1982 }
1983
1984 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1985   int jdimension  ;
1986
1987   if (!swig_callbackOnCalculateRelayoutSize) {
1988     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1989     return;
1990   } else {
1991     jdimension = (int)dimension;
1992     swig_callbackOnCalculateRelayoutSize(jdimension);
1993   }
1994 }
1995
1996 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1997   float jsize  ;
1998   int jdimension  ;
1999
2000   if (!swig_callbackOnLayoutNegotiated) {
2001     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2002     return;
2003   } else {
2004     jsize = size;
2005     jdimension = (int)dimension;
2006     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2007   }
2008 }
2009
2010 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2011   return Dali::CustomActorImpl::GetExtension();
2012 }
2013
2014 void SwigDirector_ViewImpl::OnInitialize() {
2015   if (!swig_callbackOnInitialize) {
2016     Dali::Toolkit::Internal::Control::OnInitialize();
2017     return;
2018   } else {
2019     swig_callbackOnInitialize();
2020   }
2021 }
2022
2023 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2024   void * jchild = 0 ;
2025
2026   if (!swig_callbackOnControlChildAdd) {
2027     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2028     return;
2029   } else {
2030     jchild = (Dali::Actor *) &child;
2031     swig_callbackOnControlChildAdd(jchild);
2032   }
2033 }
2034
2035 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2036   void * jchild = 0 ;
2037
2038   if (!swig_callbackOnControlChildRemove) {
2039     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2040     return;
2041   } else {
2042     jchild = (Dali::Actor *) &child;
2043     swig_callbackOnControlChildRemove(jchild);
2044   }
2045 }
2046
2047 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2048   void * jstyleManager  ;
2049   int jchange  ;
2050
2051   if (!swig_callbackOnStyleChange) {
2052     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2053     return;
2054   } else {
2055     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2056     jchange = (int)change;
2057     swig_callbackOnStyleChange(jstyleManager, jchange);
2058   }
2059 }
2060
2061 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2062   bool c_result = SwigValueInit< bool >() ;
2063   unsigned int jresult = 0 ;
2064
2065   if (!swig_callbackOnAccessibilityActivated) {
2066     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2067   } else {
2068     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2069     c_result = jresult ? true : false;
2070   }
2071   return c_result;
2072 }
2073
2074 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2075   bool c_result = SwigValueInit< bool >() ;
2076   unsigned int jresult = 0 ;
2077   void * jgesture  ;
2078
2079   if (!swig_callbackOnAccessibilityPan) {
2080     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2081   } else {
2082     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2083     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2084     c_result = jresult ? true : false;
2085   }
2086   return c_result;
2087 }
2088
2089 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2090   bool c_result = SwigValueInit< bool >() ;
2091   unsigned int jresult = 0 ;
2092   void * jtouchEvent = 0 ;
2093
2094   if (!swig_callbackOnAccessibilityTouch) {
2095     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2096   } else {
2097     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2098     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2099     c_result = jresult ? true : false;
2100   }
2101   return c_result;
2102 }
2103
2104 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2105   bool c_result = SwigValueInit< bool >() ;
2106   unsigned int jresult = 0 ;
2107   unsigned int jisIncrease  ;
2108
2109   if (!swig_callbackOnAccessibilityValueChange) {
2110     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2111   } else {
2112     jisIncrease = isIncrease;
2113     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2114     c_result = jresult ? true : false;
2115   }
2116   return c_result;
2117 }
2118
2119 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2120   bool c_result = SwigValueInit< bool >() ;
2121   unsigned int jresult = 0 ;
2122
2123   if (!swig_callbackOnAccessibilityZoom) {
2124     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2125   } else {
2126     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2127     c_result = jresult ? true : false;
2128   }
2129   return c_result;
2130 }
2131
2132 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2133   if (!swig_callbackOnKeyInputFocusGained) {
2134     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2135     return;
2136   } else {
2137     swig_callbackOnKeyInputFocusGained();
2138   }
2139 }
2140
2141 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2142   if (!swig_callbackOnKeyInputFocusLost) {
2143     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2144     return;
2145   } else {
2146     swig_callbackOnKeyInputFocusLost();
2147   }
2148 }
2149
2150 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2151   Dali::Actor c_result ;
2152   void * jresult = 0 ;
2153   void * jcurrentFocusedActor  ;
2154   int jdirection  ;
2155   unsigned int jloopEnabled  ;
2156
2157   if (!swig_callbackGetNextKeyboardFocusableActor) {
2158     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2159   } else {
2160     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2161     jdirection = (int)direction;
2162     jloopEnabled = loopEnabled;
2163     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2164     if (!jresult) {
2165       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2166       return c_result;
2167     }
2168     c_result = *(Dali::Actor *)jresult;
2169   }
2170   return c_result;
2171 }
2172
2173 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2174   void * jcommitedFocusableActor  ;
2175
2176   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2177     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2178     return;
2179   } else {
2180     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2181     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2182   }
2183 }
2184
2185 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2186   bool c_result = SwigValueInit< bool >() ;
2187   unsigned int jresult = 0 ;
2188
2189   if (!swig_callbackOnKeyboardEnter) {
2190     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2191   } else {
2192     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2193     c_result = jresult ? true : false;
2194   }
2195   return c_result;
2196 }
2197
2198 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2199   void * jpinch = 0 ;
2200
2201   if (!swig_callbackOnPinch) {
2202     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2203     return;
2204   } else {
2205     jpinch = (Dali::PinchGesture *) &pinch;
2206     swig_callbackOnPinch(jpinch);
2207   }
2208 }
2209
2210 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2211   void * jpan = 0 ;
2212
2213   if (!swig_callbackOnPan) {
2214     Dali::Toolkit::Internal::Control::OnPan(pan);
2215     return;
2216   } else {
2217     jpan = (Dali::PanGesture *) &pan;
2218     swig_callbackOnPan(jpan);
2219   }
2220 }
2221
2222 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2223   void * jtap = 0 ;
2224
2225   if (!swig_callbackOnTap) {
2226     Dali::Toolkit::Internal::Control::OnTap(tap);
2227     return;
2228   } else {
2229     jtap = (Dali::TapGesture *) &tap;
2230     swig_callbackOnTap(jtap);
2231   }
2232 }
2233
2234 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2235   void * jlongPress = 0 ;
2236
2237   if (!swig_callbackOnLongPress) {
2238     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2239     return;
2240   } else {
2241     jlongPress = (Dali::LongPressGesture *) &longPress;
2242     swig_callbackOnLongPress(jlongPress);
2243   }
2244 }
2245
2246 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2247   void * jslotObserver = 0 ;
2248   void * jcallback = 0 ;
2249
2250   if (!swig_callbackSignalConnected) {
2251     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2252     return;
2253   } else {
2254     jslotObserver = (void *) slotObserver;
2255     jcallback = (void *) callback;
2256     swig_callbackSignalConnected(jslotObserver, jcallback);
2257   }
2258 }
2259
2260 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2261   void * jslotObserver = 0 ;
2262   void * jcallback = 0 ;
2263
2264   if (!swig_callbackSignalDisconnected) {
2265     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2266     return;
2267   } else {
2268     jslotObserver = (void *) slotObserver;
2269     jcallback = (void *) callback;
2270     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2271   }
2272 }
2273
2274 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2275   return Dali::Toolkit::Internal::Control::GetControlExtension();
2276 }
2277
2278 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) {
2279   swig_callbackOnStageConnection = callbackOnStageConnection;
2280   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2281   swig_callbackOnChildAdd = callbackOnChildAdd;
2282   swig_callbackOnChildRemove = callbackOnChildRemove;
2283   swig_callbackOnPropertySet = callbackOnPropertySet;
2284   swig_callbackOnSizeSet = callbackOnSizeSet;
2285   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2286   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2287   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2288   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2289   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2290   swig_callbackOnRelayout = callbackOnRelayout;
2291   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2292   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2293   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2294   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2295   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2296   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2297   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2298   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2299   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2300   swig_callbackOnInitialize = callbackOnInitialize;
2301   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2302   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2303   swig_callbackOnStyleChange = callbackOnStyleChange;
2304   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2305   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2306   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2307   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2308   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2309   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2310   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2311   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2312   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2313   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2314   swig_callbackOnPinch = callbackOnPinch;
2315   swig_callbackOnPan = callbackOnPan;
2316   swig_callbackOnTap = callbackOnTap;
2317   swig_callbackOnLongPress = callbackOnLongPress;
2318   swig_callbackSignalConnected = callbackSignalConnected;
2319   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2320 }
2321
2322 void SwigDirector_ViewImpl::swig_init_callbacks() {
2323   swig_callbackOnStageConnection = 0;
2324   swig_callbackOnStageDisconnection = 0;
2325   swig_callbackOnChildAdd = 0;
2326   swig_callbackOnChildRemove = 0;
2327   swig_callbackOnPropertySet = 0;
2328   swig_callbackOnSizeSet = 0;
2329   swig_callbackOnSizeAnimation = 0;
2330   swig_callbackOnTouchEvent = 0;
2331   swig_callbackOnHoverEvent = 0;
2332   swig_callbackOnKeyEvent = 0;
2333   swig_callbackOnWheelEvent = 0;
2334   swig_callbackOnRelayout = 0;
2335   swig_callbackOnSetResizePolicy = 0;
2336   swig_callbackGetNaturalSize = 0;
2337   swig_callbackCalculateChildSize = 0;
2338   swig_callbackGetHeightForWidth = 0;
2339   swig_callbackGetWidthForHeight = 0;
2340   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2341   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2342   swig_callbackOnCalculateRelayoutSize = 0;
2343   swig_callbackOnLayoutNegotiated = 0;
2344   swig_callbackOnInitialize = 0;
2345   swig_callbackOnControlChildAdd = 0;
2346   swig_callbackOnControlChildRemove = 0;
2347   swig_callbackOnStyleChange = 0;
2348   swig_callbackOnAccessibilityActivated = 0;
2349   swig_callbackOnAccessibilityPan = 0;
2350   swig_callbackOnAccessibilityTouch = 0;
2351   swig_callbackOnAccessibilityValueChange = 0;
2352   swig_callbackOnAccessibilityZoom = 0;
2353   swig_callbackOnKeyInputFocusGained = 0;
2354   swig_callbackOnKeyInputFocusLost = 0;
2355   swig_callbackGetNextKeyboardFocusableActor = 0;
2356   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2357   swig_callbackOnKeyboardEnter = 0;
2358   swig_callbackOnPinch = 0;
2359   swig_callbackOnPan = 0;
2360   swig_callbackOnTap = 0;
2361   swig_callbackOnLongPress = 0;
2362   swig_callbackSignalConnected = 0;
2363   swig_callbackSignalDisconnected = 0;
2364 }
2365
2366 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2367   swig_init_callbacks();
2368 }
2369
2370 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2371
2372 }
2373
2374
2375 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2376   unsigned int c_result = SwigValueInit< unsigned int >() ;
2377   unsigned int jresult = 0 ;
2378
2379   if (!swig_callbackGetNumberOfItems) {
2380     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2381   } else {
2382     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2383     c_result = (unsigned int)jresult;
2384   }
2385   return c_result;
2386 }
2387
2388 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2389   Dali::Actor c_result ;
2390   void * jresult = 0 ;
2391   unsigned int jitemId  ;
2392
2393   if (!swig_callbackNewItem) {
2394     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2395   } else {
2396     jitemId = itemId;
2397     jresult = (void *) swig_callbackNewItem(jitemId);
2398     if (!jresult) {
2399       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2400       return c_result;
2401     }
2402     c_result = *(Dali::Actor *)jresult;
2403   }
2404   return c_result;
2405 }
2406
2407 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2408   unsigned int jitemId  ;
2409   void * jactor  ;
2410
2411   if (!swig_callbackItemReleased) {
2412     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2413     return;
2414   } else {
2415     jitemId = itemId;
2416     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2417     swig_callbackItemReleased(jitemId, jactor);
2418   }
2419 }
2420
2421 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2422   return Dali::Toolkit::ItemFactory::GetExtension();
2423 }
2424
2425 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2426   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2427   swig_callbackNewItem = callbackNewItem;
2428   swig_callbackItemReleased = callbackItemReleased;
2429 }
2430
2431 void SwigDirector_ItemFactory::swig_init_callbacks() {
2432   swig_callbackGetNumberOfItems = 0;
2433   swig_callbackNewItem = 0;
2434   swig_callbackItemReleased = 0;
2435 }
2436
2437 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2438   swig_init_callbacks();
2439 }
2440
2441 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2442
2443 }
2444
2445
2446 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2447   Dali::Actor c_result ;
2448   void * jresult = 0 ;
2449   void * jcurrent  ;
2450   void * jproposed  ;
2451   int jdirection  ;
2452
2453   if (!swig_callbackGetNextFocusableActor) {
2454     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2455   } else {
2456     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2457     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2458     jdirection = (int)direction;
2459     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2460     if (!jresult) {
2461       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2462       return c_result;
2463     }
2464     c_result = *(Dali::Actor *)jresult;
2465   }
2466   return c_result;
2467 }
2468
2469 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2470   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2471 }
2472
2473 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2474   swig_callbackGetNextFocusableActor = 0;
2475 }
2476
2477
2478 #ifdef __cplusplus
2479 extern "C" {
2480 #endif
2481
2482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2483   void * jresult ;
2484   floatp *result = 0 ;
2485
2486   {
2487     try {
2488       result = (floatp *)new_floatp();
2489     } catch (std::out_of_range& e) {
2490       {
2491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2492       };
2493     } catch (std::exception& e) {
2494       {
2495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2496       };
2497     } catch (...) {
2498       {
2499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2500       };
2501     }
2502   }
2503   jresult = (void *)result;
2504   return jresult;
2505 }
2506
2507
2508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2509   floatp *arg1 = (floatp *) 0 ;
2510
2511   arg1 = (floatp *)jarg1;
2512   {
2513     try {
2514       delete_floatp(arg1);
2515     } catch (std::out_of_range& e) {
2516       {
2517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2518       };
2519     } catch (std::exception& e) {
2520       {
2521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2522       };
2523     } catch (...) {
2524       {
2525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2526       };
2527     }
2528   }
2529 }
2530
2531
2532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2533   floatp *arg1 = (floatp *) 0 ;
2534   float arg2 ;
2535
2536   arg1 = (floatp *)jarg1;
2537   arg2 = (float)jarg2;
2538   {
2539     try {
2540       floatp_assign(arg1,arg2);
2541     } catch (std::out_of_range& e) {
2542       {
2543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2544       };
2545     } catch (std::exception& e) {
2546       {
2547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2548       };
2549     } catch (...) {
2550       {
2551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2552       };
2553     }
2554   }
2555 }
2556
2557
2558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2559   float jresult ;
2560   floatp *arg1 = (floatp *) 0 ;
2561   float result;
2562
2563   arg1 = (floatp *)jarg1;
2564   {
2565     try {
2566       result = (float)floatp_value(arg1);
2567     } catch (std::out_of_range& e) {
2568       {
2569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2570       };
2571     } catch (std::exception& e) {
2572       {
2573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2574       };
2575     } catch (...) {
2576       {
2577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2578       };
2579     }
2580   }
2581   jresult = result;
2582   return jresult;
2583 }
2584
2585
2586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2587   void * jresult ;
2588   floatp *arg1 = (floatp *) 0 ;
2589   float *result = 0 ;
2590
2591   arg1 = (floatp *)jarg1;
2592   {
2593     try {
2594       result = (float *)floatp_cast(arg1);
2595     } catch (std::out_of_range& e) {
2596       {
2597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2598       };
2599     } catch (std::exception& e) {
2600       {
2601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (...) {
2604       {
2605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2606       };
2607     }
2608   }
2609   jresult = (void *)result;
2610   return jresult;
2611 }
2612
2613
2614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2615   void * jresult ;
2616   float *arg1 = (float *) 0 ;
2617   floatp *result = 0 ;
2618
2619   arg1 = (float *)jarg1;
2620   {
2621     try {
2622       result = (floatp *)floatp_frompointer(arg1);
2623     } catch (std::out_of_range& e) {
2624       {
2625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2626       };
2627     } catch (std::exception& e) {
2628       {
2629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2630       };
2631     } catch (...) {
2632       {
2633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2634       };
2635     }
2636   }
2637   jresult = (void *)result;
2638   return jresult;
2639 }
2640
2641
2642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2643   void * jresult ;
2644   intp *result = 0 ;
2645
2646   {
2647     try {
2648       result = (intp *)new_intp();
2649     } catch (std::out_of_range& e) {
2650       {
2651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2652       };
2653     } catch (std::exception& e) {
2654       {
2655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2656       };
2657     } catch (...) {
2658       {
2659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2660       };
2661     }
2662   }
2663   jresult = (void *)result;
2664   return jresult;
2665 }
2666
2667
2668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2669   intp *arg1 = (intp *) 0 ;
2670
2671   arg1 = (intp *)jarg1;
2672   {
2673     try {
2674       delete_intp(arg1);
2675     } catch (std::out_of_range& e) {
2676       {
2677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2678       };
2679     } catch (std::exception& e) {
2680       {
2681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2682       };
2683     } catch (...) {
2684       {
2685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2686       };
2687     }
2688   }
2689 }
2690
2691
2692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2693   intp *arg1 = (intp *) 0 ;
2694   int arg2 ;
2695
2696   arg1 = (intp *)jarg1;
2697   arg2 = (int)jarg2;
2698   {
2699     try {
2700       intp_assign(arg1,arg2);
2701     } catch (std::out_of_range& e) {
2702       {
2703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2704       };
2705     } catch (std::exception& e) {
2706       {
2707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2708       };
2709     } catch (...) {
2710       {
2711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2712       };
2713     }
2714   }
2715 }
2716
2717
2718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2719   int jresult ;
2720   intp *arg1 = (intp *) 0 ;
2721   int result;
2722
2723   arg1 = (intp *)jarg1;
2724   {
2725     try {
2726       result = (int)intp_value(arg1);
2727     } catch (std::out_of_range& e) {
2728       {
2729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (std::exception& e) {
2732       {
2733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741   jresult = result;
2742   return jresult;
2743 }
2744
2745
2746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2747   void * jresult ;
2748   intp *arg1 = (intp *) 0 ;
2749   int *result = 0 ;
2750
2751   arg1 = (intp *)jarg1;
2752   {
2753     try {
2754       result = (int *)intp_cast(arg1);
2755     } catch (std::out_of_range& e) {
2756       {
2757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2758       };
2759     } catch (std::exception& e) {
2760       {
2761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2762       };
2763     } catch (...) {
2764       {
2765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2766       };
2767     }
2768   }
2769   jresult = (void *)result;
2770   return jresult;
2771 }
2772
2773
2774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2775   void * jresult ;
2776   int *arg1 = (int *) 0 ;
2777   intp *result = 0 ;
2778
2779   arg1 = (int *)jarg1;
2780   {
2781     try {
2782       result = (intp *)intp_frompointer(arg1);
2783     } catch (std::out_of_range& e) {
2784       {
2785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2786       };
2787     } catch (std::exception& e) {
2788       {
2789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (...) {
2792       {
2793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2794       };
2795     }
2796   }
2797   jresult = (void *)result;
2798   return jresult;
2799 }
2800
2801
2802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2803   void * jresult ;
2804   doublep *result = 0 ;
2805
2806   {
2807     try {
2808       result = (doublep *)new_doublep();
2809     } catch (std::out_of_range& e) {
2810       {
2811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2812       };
2813     } catch (std::exception& e) {
2814       {
2815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2816       };
2817     } catch (...) {
2818       {
2819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2820       };
2821     }
2822   }
2823   jresult = (void *)result;
2824   return jresult;
2825 }
2826
2827
2828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2829   doublep *arg1 = (doublep *) 0 ;
2830
2831   arg1 = (doublep *)jarg1;
2832   {
2833     try {
2834       delete_doublep(arg1);
2835     } catch (std::out_of_range& e) {
2836       {
2837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2838       };
2839     } catch (std::exception& e) {
2840       {
2841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2842       };
2843     } catch (...) {
2844       {
2845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2846       };
2847     }
2848   }
2849 }
2850
2851
2852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2853   doublep *arg1 = (doublep *) 0 ;
2854   double arg2 ;
2855
2856   arg1 = (doublep *)jarg1;
2857   arg2 = (double)jarg2;
2858   {
2859     try {
2860       doublep_assign(arg1,arg2);
2861     } catch (std::out_of_range& e) {
2862       {
2863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2864       };
2865     } catch (std::exception& e) {
2866       {
2867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2868       };
2869     } catch (...) {
2870       {
2871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2872       };
2873     }
2874   }
2875 }
2876
2877
2878 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2879   double jresult ;
2880   doublep *arg1 = (doublep *) 0 ;
2881   double result;
2882
2883   arg1 = (doublep *)jarg1;
2884   {
2885     try {
2886       result = (double)doublep_value(arg1);
2887     } catch (std::out_of_range& e) {
2888       {
2889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2890       };
2891     } catch (std::exception& e) {
2892       {
2893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2894       };
2895     } catch (...) {
2896       {
2897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2898       };
2899     }
2900   }
2901   jresult = result;
2902   return jresult;
2903 }
2904
2905
2906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2907   void * jresult ;
2908   doublep *arg1 = (doublep *) 0 ;
2909   double *result = 0 ;
2910
2911   arg1 = (doublep *)jarg1;
2912   {
2913     try {
2914       result = (double *)doublep_cast(arg1);
2915     } catch (std::out_of_range& e) {
2916       {
2917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2918       };
2919     } catch (std::exception& e) {
2920       {
2921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2922       };
2923     } catch (...) {
2924       {
2925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2926       };
2927     }
2928   }
2929   jresult = (void *)result;
2930   return jresult;
2931 }
2932
2933
2934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2935   void * jresult ;
2936   double *arg1 = (double *) 0 ;
2937   doublep *result = 0 ;
2938
2939   arg1 = (double *)jarg1;
2940   {
2941     try {
2942       result = (doublep *)doublep_frompointer(arg1);
2943     } catch (std::out_of_range& e) {
2944       {
2945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2946       };
2947     } catch (std::exception& e) {
2948       {
2949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (...) {
2952       {
2953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2954       };
2955     }
2956   }
2957   jresult = (void *)result;
2958   return jresult;
2959 }
2960
2961
2962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2963   void * jresult ;
2964   uintp *result = 0 ;
2965
2966   {
2967     try {
2968       result = (uintp *)new_uintp();
2969     } catch (std::out_of_range& e) {
2970       {
2971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2972       };
2973     } catch (std::exception& e) {
2974       {
2975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2976       };
2977     } catch (...) {
2978       {
2979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2980       };
2981     }
2982   }
2983   jresult = (void *)result;
2984   return jresult;
2985 }
2986
2987
2988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2989   uintp *arg1 = (uintp *) 0 ;
2990
2991   arg1 = (uintp *)jarg1;
2992   {
2993     try {
2994       delete_uintp(arg1);
2995     } catch (std::out_of_range& e) {
2996       {
2997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2998       };
2999     } catch (std::exception& e) {
3000       {
3001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3002       };
3003     } catch (...) {
3004       {
3005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3006       };
3007     }
3008   }
3009 }
3010
3011
3012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3013   uintp *arg1 = (uintp *) 0 ;
3014   unsigned int arg2 ;
3015
3016   arg1 = (uintp *)jarg1;
3017   arg2 = (unsigned int)jarg2;
3018   {
3019     try {
3020       uintp_assign(arg1,arg2);
3021     } catch (std::out_of_range& e) {
3022       {
3023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3024       };
3025     } catch (std::exception& e) {
3026       {
3027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3028       };
3029     } catch (...) {
3030       {
3031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3032       };
3033     }
3034   }
3035 }
3036
3037
3038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3039   unsigned int jresult ;
3040   uintp *arg1 = (uintp *) 0 ;
3041   unsigned int result;
3042
3043   arg1 = (uintp *)jarg1;
3044   {
3045     try {
3046       result = (unsigned int)uintp_value(arg1);
3047     } catch (std::out_of_range& e) {
3048       {
3049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3050       };
3051     } catch (std::exception& e) {
3052       {
3053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3054       };
3055     } catch (...) {
3056       {
3057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3058       };
3059     }
3060   }
3061   jresult = result;
3062   return jresult;
3063 }
3064
3065
3066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3067   void * jresult ;
3068   uintp *arg1 = (uintp *) 0 ;
3069   unsigned int *result = 0 ;
3070
3071   arg1 = (uintp *)jarg1;
3072   {
3073     try {
3074       result = (unsigned int *)uintp_cast(arg1);
3075     } catch (std::out_of_range& e) {
3076       {
3077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3078       };
3079     } catch (std::exception& e) {
3080       {
3081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3082       };
3083     } catch (...) {
3084       {
3085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3086       };
3087     }
3088   }
3089   jresult = (void *)result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3095   void * jresult ;
3096   unsigned int *arg1 = (unsigned int *) 0 ;
3097   uintp *result = 0 ;
3098
3099   arg1 = (unsigned int *)jarg1;
3100   {
3101     try {
3102       result = (uintp *)uintp_frompointer(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (...) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3114       };
3115     }
3116   }
3117   jresult = (void *)result;
3118   return jresult;
3119 }
3120
3121
3122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3123   void * jresult ;
3124   ushortp *result = 0 ;
3125
3126   {
3127     try {
3128       result = (ushortp *)new_ushortp();
3129     } catch (std::out_of_range& e) {
3130       {
3131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3132       };
3133     } catch (std::exception& e) {
3134       {
3135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (...) {
3138       {
3139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3140       };
3141     }
3142   }
3143   jresult = (void *)result;
3144   return jresult;
3145 }
3146
3147
3148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3149   ushortp *arg1 = (ushortp *) 0 ;
3150
3151   arg1 = (ushortp *)jarg1;
3152   {
3153     try {
3154       delete_ushortp(arg1);
3155     } catch (std::out_of_range& e) {
3156       {
3157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3158       };
3159     } catch (std::exception& e) {
3160       {
3161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3166       };
3167     }
3168   }
3169 }
3170
3171
3172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3173   ushortp *arg1 = (ushortp *) 0 ;
3174   unsigned short arg2 ;
3175
3176   arg1 = (ushortp *)jarg1;
3177   arg2 = (unsigned short)jarg2;
3178   {
3179     try {
3180       ushortp_assign(arg1,arg2);
3181     } catch (std::out_of_range& e) {
3182       {
3183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3184       };
3185     } catch (std::exception& e) {
3186       {
3187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3188       };
3189     } catch (...) {
3190       {
3191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3192       };
3193     }
3194   }
3195 }
3196
3197
3198 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3199   unsigned short jresult ;
3200   ushortp *arg1 = (ushortp *) 0 ;
3201   unsigned short result;
3202
3203   arg1 = (ushortp *)jarg1;
3204   {
3205     try {
3206       result = (unsigned short)ushortp_value(arg1);
3207     } catch (std::out_of_range& e) {
3208       {
3209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3210       };
3211     } catch (std::exception& e) {
3212       {
3213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3214       };
3215     } catch (...) {
3216       {
3217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3218       };
3219     }
3220   }
3221   jresult = result;
3222   return jresult;
3223 }
3224
3225
3226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3227   void * jresult ;
3228   ushortp *arg1 = (ushortp *) 0 ;
3229   unsigned short *result = 0 ;
3230
3231   arg1 = (ushortp *)jarg1;
3232   {
3233     try {
3234       result = (unsigned short *)ushortp_cast(arg1);
3235     } catch (std::out_of_range& e) {
3236       {
3237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3238       };
3239     } catch (std::exception& e) {
3240       {
3241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3242       };
3243     } catch (...) {
3244       {
3245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3246       };
3247     }
3248   }
3249   jresult = (void *)result;
3250   return jresult;
3251 }
3252
3253
3254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3255   void * jresult ;
3256   unsigned short *arg1 = (unsigned short *) 0 ;
3257   ushortp *result = 0 ;
3258
3259   arg1 = (unsigned short *)jarg1;
3260   {
3261     try {
3262       result = (ushortp *)ushortp_frompointer(arg1);
3263     } catch (std::out_of_range& e) {
3264       {
3265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3266       };
3267     } catch (std::exception& e) {
3268       {
3269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3270       };
3271     } catch (...) {
3272       {
3273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3274       };
3275     }
3276   }
3277   jresult = (void *)result;
3278   return jresult;
3279 }
3280
3281
3282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3283   unsigned int jresult ;
3284   int arg1 ;
3285   unsigned int result;
3286
3287   arg1 = (int)jarg1;
3288   {
3289     try {
3290       result = (unsigned int)int_to_uint(arg1);
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (...) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3302       };
3303     }
3304   }
3305   jresult = result;
3306   return jresult;
3307 }
3308
3309
3310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3311   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3312
3313   arg1 = (Dali::RefObject *)jarg1;
3314   {
3315     try {
3316       (arg1)->Reference();
3317     } catch (std::out_of_range& e) {
3318       {
3319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3320       };
3321     } catch (std::exception& e) {
3322       {
3323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3324       };
3325     } catch (...) {
3326       {
3327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3328       };
3329     }
3330   }
3331 }
3332
3333
3334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3335   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3336
3337   arg1 = (Dali::RefObject *)jarg1;
3338   {
3339     try {
3340       (arg1)->Unreference();
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3348       };
3349     } catch (...) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3352       };
3353     }
3354   }
3355 }
3356
3357
3358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3359   int jresult ;
3360   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3361   int result;
3362
3363   arg1 = (Dali::RefObject *)jarg1;
3364   {
3365     try {
3366       result = (int)(arg1)->ReferenceCount();
3367     } catch (std::out_of_range& e) {
3368       {
3369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3370       };
3371     } catch (std::exception& e) {
3372       {
3373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3374       };
3375     } catch (...) {
3376       {
3377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3378       };
3379     }
3380   }
3381   jresult = result;
3382   return jresult;
3383 }
3384
3385
3386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3387   void * jresult ;
3388   Dali::Any *result = 0 ;
3389
3390   {
3391     try {
3392       result = (Dali::Any *)new Dali::Any();
3393     } catch (std::out_of_range& e) {
3394       {
3395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3396       };
3397     } catch (std::exception& e) {
3398       {
3399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3400       };
3401     } catch (...) {
3402       {
3403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3404       };
3405     }
3406   }
3407   jresult = (void *)result;
3408   return jresult;
3409 }
3410
3411
3412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3413   Dali::Any *arg1 = (Dali::Any *) 0 ;
3414
3415   arg1 = (Dali::Any *)jarg1;
3416   {
3417     try {
3418       delete arg1;
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (...) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3430       };
3431     }
3432   }
3433 }
3434
3435
3436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3437   char *arg1 = (char *) 0 ;
3438
3439   arg1 = (char *)jarg1;
3440   {
3441     try {
3442       Dali::Any::AssertAlways((char const *)arg1);
3443     } catch (std::out_of_range& e) {
3444       {
3445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3446       };
3447     } catch (std::exception& e) {
3448       {
3449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3450       };
3451     } catch (...) {
3452       {
3453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3454       };
3455     }
3456   }
3457 }
3458
3459
3460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3461   void * jresult ;
3462   Dali::Any *arg1 = 0 ;
3463   Dali::Any *result = 0 ;
3464
3465   arg1 = (Dali::Any *)jarg1;
3466   if (!arg1) {
3467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3468     return 0;
3469   }
3470   {
3471     try {
3472       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3473     } catch (std::out_of_range& e) {
3474       {
3475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3476       };
3477     } catch (std::exception& e) {
3478       {
3479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3480       };
3481     } catch (...) {
3482       {
3483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3484       };
3485     }
3486   }
3487   jresult = (void *)result;
3488   return jresult;
3489 }
3490
3491
3492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3493   void * jresult ;
3494   Dali::Any *arg1 = (Dali::Any *) 0 ;
3495   Dali::Any *arg2 = 0 ;
3496   Dali::Any *result = 0 ;
3497
3498   arg1 = (Dali::Any *)jarg1;
3499   arg2 = (Dali::Any *)jarg2;
3500   if (!arg2) {
3501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3502     return 0;
3503   }
3504   {
3505     try {
3506       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3507     } catch (std::out_of_range& e) {
3508       {
3509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3510       };
3511     } catch (std::exception& e) {
3512       {
3513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3514       };
3515     } catch (...) {
3516       {
3517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3518       };
3519     }
3520   }
3521   jresult = (void *)result;
3522   return jresult;
3523 }
3524
3525
3526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3527   void * jresult ;
3528   Dali::Any *arg1 = (Dali::Any *) 0 ;
3529   std::type_info *result = 0 ;
3530
3531   arg1 = (Dali::Any *)jarg1;
3532   {
3533     try {
3534       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3535     } catch (std::out_of_range& e) {
3536       {
3537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3538       };
3539     } catch (std::exception& e) {
3540       {
3541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3542       };
3543     } catch (...) {
3544       {
3545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3546       };
3547     }
3548   }
3549   jresult = (void *)result;
3550   return jresult;
3551 }
3552
3553
3554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3555   unsigned int jresult ;
3556   Dali::Any *arg1 = (Dali::Any *) 0 ;
3557   bool result;
3558
3559   arg1 = (Dali::Any *)jarg1;
3560   {
3561     try {
3562       result = (bool)((Dali::Any const *)arg1)->Empty();
3563     } catch (std::out_of_range& e) {
3564       {
3565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3566       };
3567     } catch (std::exception& e) {
3568       {
3569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3570       };
3571     } catch (...) {
3572       {
3573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3574       };
3575     }
3576   }
3577   jresult = result;
3578   return jresult;
3579 }
3580
3581
3582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3583   void * jresult ;
3584   std::type_info *arg1 = 0 ;
3585   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3586   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3587   Dali::Any::AnyContainerBase *result = 0 ;
3588
3589   arg1 = (std::type_info *)jarg1;
3590   if (!arg1) {
3591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3592     return 0;
3593   }
3594   arg2 = (Dali::Any::CloneFunc)jarg2;
3595   arg3 = (Dali::Any::DeleteFunc)jarg3;
3596   {
3597     try {
3598       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3599     } catch (std::out_of_range& e) {
3600       {
3601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3602       };
3603     } catch (std::exception& e) {
3604       {
3605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3606       };
3607     } catch (...) {
3608       {
3609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3610       };
3611     }
3612   }
3613   jresult = (void *)result;
3614   return jresult;
3615 }
3616
3617
3618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3619   void * jresult ;
3620   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3621   std::type_info *result = 0 ;
3622
3623   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3624   {
3625     try {
3626       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3627     } catch (std::out_of_range& e) {
3628       {
3629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3630       };
3631     } catch (std::exception& e) {
3632       {
3633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3634       };
3635     } catch (...) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3638       };
3639     }
3640   }
3641   jresult = (void *)result;
3642   return jresult;
3643 }
3644
3645
3646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3647   void * jresult ;
3648   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3649   ::std::type_info *result = 0 ;
3650
3651   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3652   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3653   jresult = (void *)result;
3654   return jresult;
3655 }
3656
3657
3658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3659   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3660   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3661
3662   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3663   arg2 = (Dali::Any::CloneFunc)jarg2;
3664   if (arg1) (arg1)->mCloneFunc = arg2;
3665 }
3666
3667
3668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3669   void * jresult ;
3670   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3671   Dali::Any::CloneFunc result;
3672
3673   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3674   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3675   jresult = (void *)result;
3676   return jresult;
3677 }
3678
3679
3680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3681   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3682   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3683
3684   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3685   arg2 = (Dali::Any::DeleteFunc)jarg2;
3686   if (arg1) (arg1)->mDeleteFunc = arg2;
3687 }
3688
3689
3690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3691   void * jresult ;
3692   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3693   Dali::Any::DeleteFunc result;
3694
3695   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3696   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3697   jresult = (void *)result;
3698   return jresult;
3699 }
3700
3701
3702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3703   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3704
3705   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3706   {
3707     try {
3708       delete arg1;
3709     } catch (std::out_of_range& e) {
3710       {
3711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3712       };
3713     } catch (std::exception& e) {
3714       {
3715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3716       };
3717     } catch (...) {
3718       {
3719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3720       };
3721     }
3722   }
3723 }
3724
3725
3726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3727   Dali::Any *arg1 = (Dali::Any *) 0 ;
3728   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3729
3730   arg1 = (Dali::Any *)jarg1;
3731   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3732   if (arg1) (arg1)->mContainer = arg2;
3733 }
3734
3735
3736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3737   void * jresult ;
3738   Dali::Any *arg1 = (Dali::Any *) 0 ;
3739   Dali::Any::AnyContainerBase *result = 0 ;
3740
3741   arg1 = (Dali::Any *)jarg1;
3742   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3743   jresult = (void *)result;
3744   return jresult;
3745 }
3746
3747
3748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3749   char *arg1 = (char *) 0 ;
3750   char *arg2 = (char *) 0 ;
3751
3752   arg1 = (char *)jarg1;
3753   arg2 = (char *)jarg2;
3754   {
3755     try {
3756       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3757     } catch (std::out_of_range& e) {
3758       {
3759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3760       };
3761     } catch (std::exception& e) {
3762       {
3763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3764       };
3765     } catch (...) {
3766       {
3767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3768       };
3769     }
3770   }
3771 }
3772
3773
3774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3775   void * jresult ;
3776   char *arg1 = (char *) 0 ;
3777   char *arg2 = (char *) 0 ;
3778   Dali::DaliException *result = 0 ;
3779
3780   arg1 = (char *)jarg1;
3781   arg2 = (char *)jarg2;
3782   {
3783     try {
3784       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3785     } catch (std::out_of_range& e) {
3786       {
3787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3788       };
3789     } catch (std::exception& e) {
3790       {
3791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3792       };
3793     } catch (...) {
3794       {
3795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3796       };
3797     }
3798   }
3799   jresult = (void *)result;
3800   return jresult;
3801 }
3802
3803
3804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3805   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3806   char *arg2 = (char *) 0 ;
3807
3808   arg1 = (Dali::DaliException *)jarg1;
3809   arg2 = (char *)jarg2;
3810   {
3811     if (arg2) {
3812       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3813       strcpy((char *)arg1->location, (const char *)arg2);
3814     } else {
3815       arg1->location = 0;
3816     }
3817   }
3818 }
3819
3820
3821 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3822   char * jresult ;
3823   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3824   char *result = 0 ;
3825
3826   arg1 = (Dali::DaliException *)jarg1;
3827   result = (char *) ((arg1)->location);
3828   jresult = SWIG_csharp_string_callback((const char *)result);
3829   return jresult;
3830 }
3831
3832
3833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3834   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3835   char *arg2 = (char *) 0 ;
3836
3837   arg1 = (Dali::DaliException *)jarg1;
3838   arg2 = (char *)jarg2;
3839   {
3840     if (arg2) {
3841       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3842       strcpy((char *)arg1->condition, (const char *)arg2);
3843     } else {
3844       arg1->condition = 0;
3845     }
3846   }
3847 }
3848
3849
3850 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3851   char * jresult ;
3852   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3853   char *result = 0 ;
3854
3855   arg1 = (Dali::DaliException *)jarg1;
3856   result = (char *) ((arg1)->condition);
3857   jresult = SWIG_csharp_string_callback((const char *)result);
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3863   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3864
3865   arg1 = (Dali::DaliException *)jarg1;
3866   {
3867     try {
3868       delete arg1;
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3880       };
3881     }
3882   }
3883 }
3884
3885
3886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3887   void * jresult ;
3888   Dali::Vector2 *result = 0 ;
3889
3890   {
3891     try {
3892       result = (Dali::Vector2 *)new Dali::Vector2();
3893     } catch (std::out_of_range& e) {
3894       {
3895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3896       };
3897     } catch (std::exception& e) {
3898       {
3899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3900       };
3901     } catch (...) {
3902       {
3903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3904       };
3905     }
3906   }
3907   jresult = (void *)result;
3908   return jresult;
3909 }
3910
3911
3912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3913   void * jresult ;
3914   float arg1 ;
3915   float arg2 ;
3916   Dali::Vector2 *result = 0 ;
3917
3918   arg1 = (float)jarg1;
3919   arg2 = (float)jarg2;
3920   {
3921     try {
3922       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3923     } catch (std::out_of_range& e) {
3924       {
3925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3926       };
3927     } catch (std::exception& e) {
3928       {
3929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3930       };
3931     } catch (...) {
3932       {
3933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3934       };
3935     }
3936   }
3937   jresult = (void *)result;
3938   return jresult;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3943   void * jresult ;
3944   float *arg1 = (float *) 0 ;
3945   Dali::Vector2 *result = 0 ;
3946
3947   arg1 = jarg1;
3948   {
3949     try {
3950       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3951     } catch (std::out_of_range& e) {
3952       {
3953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3954       };
3955     } catch (std::exception& e) {
3956       {
3957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3958       };
3959     } catch (...) {
3960       {
3961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3962       };
3963     }
3964   }
3965   jresult = (void *)result;
3966
3967
3968   return jresult;
3969 }
3970
3971
3972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3973   void * jresult ;
3974   Dali::Vector3 *arg1 = 0 ;
3975   Dali::Vector2 *result = 0 ;
3976
3977   arg1 = (Dali::Vector3 *)jarg1;
3978   if (!arg1) {
3979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3980     return 0;
3981   }
3982   {
3983     try {
3984       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3985     } catch (std::out_of_range& e) {
3986       {
3987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3988       };
3989     } catch (std::exception& e) {
3990       {
3991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3992       };
3993     } catch (...) {
3994       {
3995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3996       };
3997     }
3998   }
3999   jresult = (void *)result;
4000   return jresult;
4001 }
4002
4003
4004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4005   void * jresult ;
4006   Dali::Vector4 *arg1 = 0 ;
4007   Dali::Vector2 *result = 0 ;
4008
4009   arg1 = (Dali::Vector4 *)jarg1;
4010   if (!arg1) {
4011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4012     return 0;
4013   }
4014   {
4015     try {
4016       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4017     } catch (std::out_of_range& e) {
4018       {
4019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4020       };
4021     } catch (std::exception& e) {
4022       {
4023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4024       };
4025     } catch (...) {
4026       {
4027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4028       };
4029     }
4030   }
4031   jresult = (void *)result;
4032   return jresult;
4033 }
4034
4035
4036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4037   void * jresult ;
4038   Dali::Vector2 *result = 0 ;
4039
4040   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4041   jresult = (void *)result;
4042   return jresult;
4043 }
4044
4045
4046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4047   void * jresult ;
4048   Dali::Vector2 *result = 0 ;
4049
4050   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4051   jresult = (void *)result;
4052   return jresult;
4053 }
4054
4055
4056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4057   void * jresult ;
4058   Dali::Vector2 *result = 0 ;
4059
4060   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4061   jresult = (void *)result;
4062   return jresult;
4063 }
4064
4065
4066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4067   void * jresult ;
4068   Dali::Vector2 *result = 0 ;
4069
4070   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4077   void * jresult ;
4078   Dali::Vector2 *result = 0 ;
4079
4080   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4081   jresult = (void *)result;
4082   return jresult;
4083 }
4084
4085
4086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4087   void * jresult ;
4088   Dali::Vector2 *result = 0 ;
4089
4090   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4091   jresult = (void *)result;
4092   return jresult;
4093 }
4094
4095
4096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4097   void * jresult ;
4098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4099   float *arg2 = (float *) 0 ;
4100   Dali::Vector2 *result = 0 ;
4101
4102   arg1 = (Dali::Vector2 *)jarg1;
4103   arg2 = jarg2;
4104   {
4105     try {
4106       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4107     } catch (std::out_of_range& e) {
4108       {
4109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4110       };
4111     } catch (std::exception& e) {
4112       {
4113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4114       };
4115     } catch (...) {
4116       {
4117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4118       };
4119     }
4120   }
4121   jresult = (void *)result;
4122
4123
4124   return jresult;
4125 }
4126
4127
4128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4129   void * jresult ;
4130   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4131   Dali::Vector3 *arg2 = 0 ;
4132   Dali::Vector2 *result = 0 ;
4133
4134   arg1 = (Dali::Vector2 *)jarg1;
4135   arg2 = (Dali::Vector3 *)jarg2;
4136   if (!arg2) {
4137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4138     return 0;
4139   }
4140   {
4141     try {
4142       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4143     } catch (std::out_of_range& e) {
4144       {
4145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4146       };
4147     } catch (std::exception& e) {
4148       {
4149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4150       };
4151     } catch (...) {
4152       {
4153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4154       };
4155     }
4156   }
4157   jresult = (void *)result;
4158   return jresult;
4159 }
4160
4161
4162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4163   void * jresult ;
4164   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4165   Dali::Vector4 *arg2 = 0 ;
4166   Dali::Vector2 *result = 0 ;
4167
4168   arg1 = (Dali::Vector2 *)jarg1;
4169   arg2 = (Dali::Vector4 *)jarg2;
4170   if (!arg2) {
4171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4172     return 0;
4173   }
4174   {
4175     try {
4176       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4177     } catch (std::out_of_range& e) {
4178       {
4179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4180       };
4181     } catch (std::exception& e) {
4182       {
4183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4184       };
4185     } catch (...) {
4186       {
4187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4188       };
4189     }
4190   }
4191   jresult = (void *)result;
4192   return jresult;
4193 }
4194
4195
4196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4197   void * jresult ;
4198   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4199   Dali::Vector2 *arg2 = 0 ;
4200   Dali::Vector2 result;
4201
4202   arg1 = (Dali::Vector2 *)jarg1;
4203   arg2 = (Dali::Vector2 *)jarg2;
4204   if (!arg2) {
4205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4206     return 0;
4207   }
4208   {
4209     try {
4210       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4211     } catch (std::out_of_range& e) {
4212       {
4213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4214       };
4215     } catch (std::exception& e) {
4216       {
4217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4218       };
4219     } catch (...) {
4220       {
4221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4222       };
4223     }
4224   }
4225   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4226   return jresult;
4227 }
4228
4229
4230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4231   void * jresult ;
4232   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4233   Dali::Vector2 *arg2 = 0 ;
4234   Dali::Vector2 *result = 0 ;
4235
4236   arg1 = (Dali::Vector2 *)jarg1;
4237   arg2 = (Dali::Vector2 *)jarg2;
4238   if (!arg2) {
4239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4240     return 0;
4241   }
4242   {
4243     try {
4244       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4245     } catch (std::out_of_range& e) {
4246       {
4247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4248       };
4249     } catch (std::exception& e) {
4250       {
4251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4252       };
4253     } catch (...) {
4254       {
4255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4256       };
4257     }
4258   }
4259   jresult = (void *)result;
4260   return jresult;
4261 }
4262
4263
4264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4265   void * jresult ;
4266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4267   Dali::Vector2 *arg2 = 0 ;
4268   Dali::Vector2 result;
4269
4270   arg1 = (Dali::Vector2 *)jarg1;
4271   arg2 = (Dali::Vector2 *)jarg2;
4272   if (!arg2) {
4273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4274     return 0;
4275   }
4276   {
4277     try {
4278       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4279     } catch (std::out_of_range& e) {
4280       {
4281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4282       };
4283     } catch (std::exception& e) {
4284       {
4285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4286       };
4287     } catch (...) {
4288       {
4289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4290       };
4291     }
4292   }
4293   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4294   return jresult;
4295 }
4296
4297
4298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4299   void * jresult ;
4300   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4301   Dali::Vector2 *arg2 = 0 ;
4302   Dali::Vector2 *result = 0 ;
4303
4304   arg1 = (Dali::Vector2 *)jarg1;
4305   arg2 = (Dali::Vector2 *)jarg2;
4306   if (!arg2) {
4307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4308     return 0;
4309   }
4310   {
4311     try {
4312       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4313     } catch (std::out_of_range& e) {
4314       {
4315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4316       };
4317     } catch (std::exception& e) {
4318       {
4319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4320       };
4321     } catch (...) {
4322       {
4323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4324       };
4325     }
4326   }
4327   jresult = (void *)result;
4328   return jresult;
4329 }
4330
4331
4332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4333   void * jresult ;
4334   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4335   Dali::Vector2 *arg2 = 0 ;
4336   Dali::Vector2 result;
4337
4338   arg1 = (Dali::Vector2 *)jarg1;
4339   arg2 = (Dali::Vector2 *)jarg2;
4340   if (!arg2) {
4341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4342     return 0;
4343   }
4344   {
4345     try {
4346       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4347     } catch (std::out_of_range& e) {
4348       {
4349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4350       };
4351     } catch (std::exception& e) {
4352       {
4353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4354       };
4355     } catch (...) {
4356       {
4357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4358       };
4359     }
4360   }
4361   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4362   return jresult;
4363 }
4364
4365
4366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4367   void * jresult ;
4368   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4369   float arg2 ;
4370   Dali::Vector2 result;
4371
4372   arg1 = (Dali::Vector2 *)jarg1;
4373   arg2 = (float)jarg2;
4374   {
4375     try {
4376       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4377     } catch (std::out_of_range& e) {
4378       {
4379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (std::exception& e) {
4382       {
4383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4384       };
4385     } catch (...) {
4386       {
4387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4388       };
4389     }
4390   }
4391   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4397   void * jresult ;
4398   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4399   Dali::Vector2 *arg2 = 0 ;
4400   Dali::Vector2 *result = 0 ;
4401
4402   arg1 = (Dali::Vector2 *)jarg1;
4403   arg2 = (Dali::Vector2 *)jarg2;
4404   if (!arg2) {
4405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4406     return 0;
4407   }
4408   {
4409     try {
4410       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4411     } catch (std::out_of_range& e) {
4412       {
4413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4414       };
4415     } catch (std::exception& e) {
4416       {
4417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4418       };
4419     } catch (...) {
4420       {
4421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4422       };
4423     }
4424   }
4425   jresult = (void *)result;
4426   return jresult;
4427 }
4428
4429
4430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4431   void * jresult ;
4432   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4433   float arg2 ;
4434   Dali::Vector2 *result = 0 ;
4435
4436   arg1 = (Dali::Vector2 *)jarg1;
4437   arg2 = (float)jarg2;
4438   {
4439     try {
4440       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4441     } catch (std::out_of_range& e) {
4442       {
4443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4444       };
4445     } catch (std::exception& e) {
4446       {
4447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4448       };
4449     } catch (...) {
4450       {
4451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4452       };
4453     }
4454   }
4455   jresult = (void *)result;
4456   return jresult;
4457 }
4458
4459
4460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4461   void * jresult ;
4462   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4463   Dali::Vector2 *arg2 = 0 ;
4464   Dali::Vector2 result;
4465
4466   arg1 = (Dali::Vector2 *)jarg1;
4467   arg2 = (Dali::Vector2 *)jarg2;
4468   if (!arg2) {
4469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4470     return 0;
4471   }
4472   {
4473     try {
4474       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4475     } catch (std::out_of_range& e) {
4476       {
4477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4478       };
4479     } catch (std::exception& e) {
4480       {
4481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4482       };
4483     } catch (...) {
4484       {
4485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4486       };
4487     }
4488   }
4489   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4495   void * jresult ;
4496   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4497   float arg2 ;
4498   Dali::Vector2 result;
4499
4500   arg1 = (Dali::Vector2 *)jarg1;
4501   arg2 = (float)jarg2;
4502   {
4503     try {
4504       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4505     } catch (std::out_of_range& e) {
4506       {
4507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4508       };
4509     } catch (std::exception& e) {
4510       {
4511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (...) {
4514       {
4515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4516       };
4517     }
4518   }
4519   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4520   return jresult;
4521 }
4522
4523
4524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4525   void * jresult ;
4526   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4527   Dali::Vector2 *arg2 = 0 ;
4528   Dali::Vector2 *result = 0 ;
4529
4530   arg1 = (Dali::Vector2 *)jarg1;
4531   arg2 = (Dali::Vector2 *)jarg2;
4532   if (!arg2) {
4533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4534     return 0;
4535   }
4536   {
4537     try {
4538       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4539     } catch (std::out_of_range& e) {
4540       {
4541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4542       };
4543     } catch (std::exception& e) {
4544       {
4545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4546       };
4547     } catch (...) {
4548       {
4549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4550       };
4551     }
4552   }
4553   jresult = (void *)result;
4554   return jresult;
4555 }
4556
4557
4558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4559   void * jresult ;
4560   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4561   float arg2 ;
4562   Dali::Vector2 *result = 0 ;
4563
4564   arg1 = (Dali::Vector2 *)jarg1;
4565   arg2 = (float)jarg2;
4566   {
4567     try {
4568       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4569     } catch (std::out_of_range& e) {
4570       {
4571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4572       };
4573     } catch (std::exception& e) {
4574       {
4575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4576       };
4577     } catch (...) {
4578       {
4579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4580       };
4581     }
4582   }
4583   jresult = (void *)result;
4584   return jresult;
4585 }
4586
4587
4588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4589   void * jresult ;
4590   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4591   Dali::Vector2 result;
4592
4593   arg1 = (Dali::Vector2 *)jarg1;
4594   {
4595     try {
4596       result = ((Dali::Vector2 const *)arg1)->operator -();
4597     } catch (std::out_of_range& e) {
4598       {
4599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4600       };
4601     } catch (std::exception& e) {
4602       {
4603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4604       };
4605     } catch (...) {
4606       {
4607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4608       };
4609     }
4610   }
4611   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4612   return jresult;
4613 }
4614
4615
4616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4617   unsigned int jresult ;
4618   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4619   Dali::Vector2 *arg2 = 0 ;
4620   bool result;
4621
4622   arg1 = (Dali::Vector2 *)jarg1;
4623   arg2 = (Dali::Vector2 *)jarg2;
4624   if (!arg2) {
4625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4626     return 0;
4627   }
4628   {
4629     try {
4630       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4631     } catch (std::out_of_range& e) {
4632       {
4633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4634       };
4635     } catch (std::exception& e) {
4636       {
4637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4638       };
4639     } catch (...) {
4640       {
4641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4642       };
4643     }
4644   }
4645   jresult = result;
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4651   unsigned int jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   Dali::Vector2 *arg2 = 0 ;
4654   bool result;
4655
4656   arg1 = (Dali::Vector2 *)jarg1;
4657   arg2 = (Dali::Vector2 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4660     return 0;
4661   }
4662   {
4663     try {
4664       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4665     } catch (std::out_of_range& e) {
4666       {
4667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (std::exception& e) {
4670       {
4671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (...) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4676       };
4677     }
4678   }
4679   jresult = result;
4680   return jresult;
4681 }
4682
4683
4684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4685   float jresult ;
4686   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4687   unsigned int arg2 ;
4688   float *result = 0 ;
4689
4690   arg1 = (Dali::Vector2 *)jarg1;
4691   arg2 = (unsigned int)jarg2;
4692   {
4693     try {
4694       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4695     } catch (std::out_of_range& e) {
4696       {
4697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4698       };
4699     } catch (std::exception& e) {
4700       {
4701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4702       };
4703     } catch (...) {
4704       {
4705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4706       };
4707     }
4708   }
4709   jresult = *result;
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4715   float jresult ;
4716   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4717   float result;
4718
4719   arg1 = (Dali::Vector2 *)jarg1;
4720   {
4721     try {
4722       result = (float)((Dali::Vector2 const *)arg1)->Length();
4723     } catch (std::out_of_range& e) {
4724       {
4725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4726       };
4727     } catch (std::exception& e) {
4728       {
4729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4730       };
4731     } catch (...) {
4732       {
4733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4734       };
4735     }
4736   }
4737   jresult = result;
4738   return jresult;
4739 }
4740
4741
4742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4743   float jresult ;
4744   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4745   float result;
4746
4747   arg1 = (Dali::Vector2 *)jarg1;
4748   {
4749     try {
4750       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4751     } catch (std::out_of_range& e) {
4752       {
4753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4754       };
4755     } catch (std::exception& e) {
4756       {
4757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4758       };
4759     } catch (...) {
4760       {
4761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4762       };
4763     }
4764   }
4765   jresult = result;
4766   return jresult;
4767 }
4768
4769
4770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   {
4775     try {
4776       (arg1)->Normalize();
4777     } catch (std::out_of_range& e) {
4778       {
4779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4780       };
4781     } catch (std::exception& e) {
4782       {
4783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4784       };
4785     } catch (...) {
4786       {
4787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4788       };
4789     }
4790   }
4791 }
4792
4793
4794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4795   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4796   Dali::Vector2 *arg2 = 0 ;
4797   Dali::Vector2 *arg3 = 0 ;
4798
4799   arg1 = (Dali::Vector2 *)jarg1;
4800   arg2 = (Dali::Vector2 *)jarg2;
4801   if (!arg2) {
4802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4803     return ;
4804   }
4805   arg3 = (Dali::Vector2 *)jarg3;
4806   if (!arg3) {
4807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4808     return ;
4809   }
4810   {
4811     try {
4812       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4813     } catch (std::out_of_range& e) {
4814       {
4815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4816       };
4817     } catch (std::exception& e) {
4818       {
4819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4820       };
4821     } catch (...) {
4822       {
4823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4824       };
4825     }
4826   }
4827 }
4828
4829
4830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4831   void * jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   float *result = 0 ;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   {
4837     try {
4838       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4839     } catch (std::out_of_range& e) {
4840       {
4841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4842       };
4843     } catch (std::exception& e) {
4844       {
4845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4846       };
4847     } catch (...) {
4848       {
4849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4850       };
4851     }
4852   }
4853   jresult = (void *)result;
4854   return jresult;
4855 }
4856
4857
4858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4859   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4860   float arg2 ;
4861
4862   arg1 = (Dali::Vector2 *)jarg1;
4863   arg2 = (float)jarg2;
4864   if (arg1) (arg1)->x = arg2;
4865 }
4866
4867
4868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4869   float jresult ;
4870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4871   float result;
4872
4873   arg1 = (Dali::Vector2 *)jarg1;
4874   result = (float) ((arg1)->x);
4875   jresult = result;
4876   return jresult;
4877 }
4878
4879
4880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4881   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4882   float arg2 ;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (float)jarg2;
4886   if (arg1) (arg1)->width = arg2;
4887 }
4888
4889
4890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4891   float jresult ;
4892   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4893   float result;
4894
4895   arg1 = (Dali::Vector2 *)jarg1;
4896   result = (float) ((arg1)->width);
4897   jresult = result;
4898   return jresult;
4899 }
4900
4901
4902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   float arg2 ;
4905
4906   arg1 = (Dali::Vector2 *)jarg1;
4907   arg2 = (float)jarg2;
4908   if (arg1) (arg1)->y = arg2;
4909 }
4910
4911
4912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4913   float jresult ;
4914   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4915   float result;
4916
4917   arg1 = (Dali::Vector2 *)jarg1;
4918   result = (float) ((arg1)->y);
4919   jresult = result;
4920   return jresult;
4921 }
4922
4923
4924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4925   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4926   float arg2 ;
4927
4928   arg1 = (Dali::Vector2 *)jarg1;
4929   arg2 = (float)jarg2;
4930   if (arg1) (arg1)->height = arg2;
4931 }
4932
4933
4934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4935   float jresult ;
4936   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4937   float result;
4938
4939   arg1 = (Dali::Vector2 *)jarg1;
4940   result = (float) ((arg1)->height);
4941   jresult = result;
4942   return jresult;
4943 }
4944
4945
4946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4947   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4948
4949   arg1 = (Dali::Vector2 *)jarg1;
4950   {
4951     try {
4952       delete arg1;
4953     } catch (std::out_of_range& e) {
4954       {
4955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4956       };
4957     } catch (std::exception& e) {
4958       {
4959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4960       };
4961     } catch (...) {
4962       {
4963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4964       };
4965     }
4966   }
4967 }
4968
4969
4970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4971   void * jresult ;
4972   Dali::Vector2 *arg1 = 0 ;
4973   Dali::Vector2 *arg2 = 0 ;
4974   Dali::Vector2 result;
4975
4976   arg1 = (Dali::Vector2 *)jarg1;
4977   if (!arg1) {
4978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4979     return 0;
4980   }
4981   arg2 = (Dali::Vector2 *)jarg2;
4982   if (!arg2) {
4983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4984     return 0;
4985   }
4986   {
4987     try {
4988       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4989     } catch (std::out_of_range& e) {
4990       {
4991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (std::exception& e) {
4994       {
4995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4996       };
4997     } catch (...) {
4998       {
4999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5000       };
5001     }
5002   }
5003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5004   return jresult;
5005 }
5006
5007
5008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5009   void * jresult ;
5010   Dali::Vector2 *arg1 = 0 ;
5011   Dali::Vector2 *arg2 = 0 ;
5012   Dali::Vector2 result;
5013
5014   arg1 = (Dali::Vector2 *)jarg1;
5015   if (!arg1) {
5016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5017     return 0;
5018   }
5019   arg2 = (Dali::Vector2 *)jarg2;
5020   if (!arg2) {
5021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5022     return 0;
5023   }
5024   {
5025     try {
5026       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5027     } catch (std::out_of_range& e) {
5028       {
5029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (std::exception& e) {
5032       {
5033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (...) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5038       };
5039     }
5040   }
5041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5042   return jresult;
5043 }
5044
5045
5046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5047   void * jresult ;
5048   Dali::Vector2 *arg1 = 0 ;
5049   float *arg2 = 0 ;
5050   float *arg3 = 0 ;
5051   float temp2 ;
5052   float temp3 ;
5053   Dali::Vector2 result;
5054
5055   arg1 = (Dali::Vector2 *)jarg1;
5056   if (!arg1) {
5057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5058     return 0;
5059   }
5060   temp2 = (float)jarg2;
5061   arg2 = &temp2;
5062   temp3 = (float)jarg3;
5063   arg3 = &temp3;
5064   {
5065     try {
5066       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5067     } catch (std::out_of_range& e) {
5068       {
5069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5070       };
5071     } catch (std::exception& e) {
5072       {
5073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (...) {
5076       {
5077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5078       };
5079     }
5080   }
5081   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5082   return jresult;
5083 }
5084
5085
5086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5087   void * jresult ;
5088   Dali::Vector3 *result = 0 ;
5089
5090   {
5091     try {
5092       result = (Dali::Vector3 *)new Dali::Vector3();
5093     } catch (std::out_of_range& e) {
5094       {
5095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5096       };
5097     } catch (std::exception& e) {
5098       {
5099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5100       };
5101     } catch (...) {
5102       {
5103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5104       };
5105     }
5106   }
5107   jresult = (void *)result;
5108   return jresult;
5109 }
5110
5111
5112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5113   void * jresult ;
5114   float arg1 ;
5115   float arg2 ;
5116   float arg3 ;
5117   Dali::Vector3 *result = 0 ;
5118
5119   arg1 = (float)jarg1;
5120   arg2 = (float)jarg2;
5121   arg3 = (float)jarg3;
5122   {
5123     try {
5124       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5125     } catch (std::out_of_range& e) {
5126       {
5127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5128       };
5129     } catch (std::exception& e) {
5130       {
5131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5132       };
5133     } catch (...) {
5134       {
5135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5136       };
5137     }
5138   }
5139   jresult = (void *)result;
5140   return jresult;
5141 }
5142
5143
5144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5145   void * jresult ;
5146   float *arg1 = (float *) 0 ;
5147   Dali::Vector3 *result = 0 ;
5148
5149   arg1 = jarg1;
5150   {
5151     try {
5152       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5153     } catch (std::out_of_range& e) {
5154       {
5155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5156       };
5157     } catch (std::exception& e) {
5158       {
5159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5160       };
5161     } catch (...) {
5162       {
5163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5164       };
5165     }
5166   }
5167   jresult = (void *)result;
5168
5169
5170   return jresult;
5171 }
5172
5173
5174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5175   void * jresult ;
5176   Dali::Vector2 *arg1 = 0 ;
5177   Dali::Vector3 *result = 0 ;
5178
5179   arg1 = (Dali::Vector2 *)jarg1;
5180   if (!arg1) {
5181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5182     return 0;
5183   }
5184   {
5185     try {
5186       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5187     } catch (std::out_of_range& e) {
5188       {
5189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5190       };
5191     } catch (std::exception& e) {
5192       {
5193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5194       };
5195     } catch (...) {
5196       {
5197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5198       };
5199     }
5200   }
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5207   void * jresult ;
5208   Dali::Vector4 *arg1 = 0 ;
5209   Dali::Vector3 *result = 0 ;
5210
5211   arg1 = (Dali::Vector4 *)jarg1;
5212   if (!arg1) {
5213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5214     return 0;
5215   }
5216   {
5217     try {
5218       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5219     } catch (std::out_of_range& e) {
5220       {
5221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (std::exception& e) {
5224       {
5225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5226       };
5227     } catch (...) {
5228       {
5229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5230       };
5231     }
5232   }
5233   jresult = (void *)result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5239   void * jresult ;
5240   Dali::Vector3 *result = 0 ;
5241
5242   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5243   jresult = (void *)result;
5244   return jresult;
5245 }
5246
5247
5248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5249   void * jresult ;
5250   Dali::Vector3 *result = 0 ;
5251
5252   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5253   jresult = (void *)result;
5254   return jresult;
5255 }
5256
5257
5258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5259   void * jresult ;
5260   Dali::Vector3 *result = 0 ;
5261
5262   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5263   jresult = (void *)result;
5264   return jresult;
5265 }
5266
5267
5268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5269   void * jresult ;
5270   Dali::Vector3 *result = 0 ;
5271
5272   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5273   jresult = (void *)result;
5274   return jresult;
5275 }
5276
5277
5278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5279   void * jresult ;
5280   Dali::Vector3 *result = 0 ;
5281
5282   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5283   jresult = (void *)result;
5284   return jresult;
5285 }
5286
5287
5288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5289   void * jresult ;
5290   Dali::Vector3 *result = 0 ;
5291
5292   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5293   jresult = (void *)result;
5294   return jresult;
5295 }
5296
5297
5298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5299   void * jresult ;
5300   Dali::Vector3 *result = 0 ;
5301
5302   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5303   jresult = (void *)result;
5304   return jresult;
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5309   void * jresult ;
5310   Dali::Vector3 *result = 0 ;
5311
5312   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5313   jresult = (void *)result;
5314   return jresult;
5315 }
5316
5317
5318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5319   void * jresult ;
5320   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5321   float *arg2 = (float *) 0 ;
5322   Dali::Vector3 *result = 0 ;
5323
5324   arg1 = (Dali::Vector3 *)jarg1;
5325   arg2 = jarg2;
5326   {
5327     try {
5328       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5329     } catch (std::out_of_range& e) {
5330       {
5331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5332       };
5333     } catch (std::exception& e) {
5334       {
5335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5336       };
5337     } catch (...) {
5338       {
5339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5340       };
5341     }
5342   }
5343   jresult = (void *)result;
5344
5345
5346   return jresult;
5347 }
5348
5349
5350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5351   void * jresult ;
5352   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5353   Dali::Vector2 *arg2 = 0 ;
5354   Dali::Vector3 *result = 0 ;
5355
5356   arg1 = (Dali::Vector3 *)jarg1;
5357   arg2 = (Dali::Vector2 *)jarg2;
5358   if (!arg2) {
5359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5360     return 0;
5361   }
5362   {
5363     try {
5364       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5365     } catch (std::out_of_range& e) {
5366       {
5367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5368       };
5369     } catch (std::exception& e) {
5370       {
5371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5372       };
5373     } catch (...) {
5374       {
5375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5376       };
5377     }
5378   }
5379   jresult = (void *)result;
5380   return jresult;
5381 }
5382
5383
5384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5385   void * jresult ;
5386   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5387   Dali::Vector4 *arg2 = 0 ;
5388   Dali::Vector3 *result = 0 ;
5389
5390   arg1 = (Dali::Vector3 *)jarg1;
5391   arg2 = (Dali::Vector4 *)jarg2;
5392   if (!arg2) {
5393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5394     return 0;
5395   }
5396   {
5397     try {
5398       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5399     } catch (std::out_of_range& e) {
5400       {
5401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5402       };
5403     } catch (std::exception& e) {
5404       {
5405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5406       };
5407     } catch (...) {
5408       {
5409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5410       };
5411     }
5412   }
5413   jresult = (void *)result;
5414   return jresult;
5415 }
5416
5417
5418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5419   void * jresult ;
5420   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5421   Dali::Vector3 *arg2 = 0 ;
5422   Dali::Vector3 result;
5423
5424   arg1 = (Dali::Vector3 *)jarg1;
5425   arg2 = (Dali::Vector3 *)jarg2;
5426   if (!arg2) {
5427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5428     return 0;
5429   }
5430   {
5431     try {
5432       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5440       };
5441     } catch (...) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5444       };
5445     }
5446   }
5447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5448   return jresult;
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5455   Dali::Vector3 *arg2 = 0 ;
5456   Dali::Vector3 *result = 0 ;
5457
5458   arg1 = (Dali::Vector3 *)jarg1;
5459   arg2 = (Dali::Vector3 *)jarg2;
5460   if (!arg2) {
5461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5462     return 0;
5463   }
5464   {
5465     try {
5466       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5467     } catch (std::out_of_range& e) {
5468       {
5469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5470       };
5471     } catch (std::exception& e) {
5472       {
5473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (...) {
5476       {
5477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5478       };
5479     }
5480   }
5481   jresult = (void *)result;
5482   return jresult;
5483 }
5484
5485
5486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5487   void * jresult ;
5488   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5489   Dali::Vector3 *arg2 = 0 ;
5490   Dali::Vector3 result;
5491
5492   arg1 = (Dali::Vector3 *)jarg1;
5493   arg2 = (Dali::Vector3 *)jarg2;
5494   if (!arg2) {
5495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5496     return 0;
5497   }
5498   {
5499     try {
5500       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5501     } catch (std::out_of_range& e) {
5502       {
5503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5504       };
5505     } catch (std::exception& e) {
5506       {
5507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5508       };
5509     } catch (...) {
5510       {
5511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5512       };
5513     }
5514   }
5515   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5516   return jresult;
5517 }
5518
5519
5520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5521   void * jresult ;
5522   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5523   Dali::Vector3 *arg2 = 0 ;
5524   Dali::Vector3 *result = 0 ;
5525
5526   arg1 = (Dali::Vector3 *)jarg1;
5527   arg2 = (Dali::Vector3 *)jarg2;
5528   if (!arg2) {
5529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5530     return 0;
5531   }
5532   {
5533     try {
5534       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5535     } catch (std::out_of_range& e) {
5536       {
5537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5538       };
5539     } catch (std::exception& e) {
5540       {
5541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5542       };
5543     } catch (...) {
5544       {
5545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5546       };
5547     }
5548   }
5549   jresult = (void *)result;
5550   return jresult;
5551 }
5552
5553
5554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5555   void * jresult ;
5556   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5557   Dali::Vector3 *arg2 = 0 ;
5558   Dali::Vector3 result;
5559
5560   arg1 = (Dali::Vector3 *)jarg1;
5561   arg2 = (Dali::Vector3 *)jarg2;
5562   if (!arg2) {
5563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5564     return 0;
5565   }
5566   {
5567     try {
5568       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5569     } catch (std::out_of_range& e) {
5570       {
5571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (std::exception& e) {
5574       {
5575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5584   return jresult;
5585 }
5586
5587
5588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5589   void * jresult ;
5590   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5591   float arg2 ;
5592   Dali::Vector3 result;
5593
5594   arg1 = (Dali::Vector3 *)jarg1;
5595   arg2 = (float)jarg2;
5596   {
5597     try {
5598       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5599     } catch (std::out_of_range& e) {
5600       {
5601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5602       };
5603     } catch (std::exception& e) {
5604       {
5605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5606       };
5607     } catch (...) {
5608       {
5609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5610       };
5611     }
5612   }
5613   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5614   return jresult;
5615 }
5616
5617
5618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5619   void * jresult ;
5620   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5621   Dali::Vector3 *arg2 = 0 ;
5622   Dali::Vector3 *result = 0 ;
5623
5624   arg1 = (Dali::Vector3 *)jarg1;
5625   arg2 = (Dali::Vector3 *)jarg2;
5626   if (!arg2) {
5627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5628     return 0;
5629   }
5630   {
5631     try {
5632       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (...) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5644       };
5645     }
5646   }
5647   jresult = (void *)result;
5648   return jresult;
5649 }
5650
5651
5652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5653   void * jresult ;
5654   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5655   float arg2 ;
5656   Dali::Vector3 *result = 0 ;
5657
5658   arg1 = (Dali::Vector3 *)jarg1;
5659   arg2 = (float)jarg2;
5660   {
5661     try {
5662       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5663     } catch (std::out_of_range& e) {
5664       {
5665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (std::exception& e) {
5668       {
5669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5670       };
5671     } catch (...) {
5672       {
5673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5674       };
5675     }
5676   }
5677   jresult = (void *)result;
5678   return jresult;
5679 }
5680
5681
5682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5683   void * jresult ;
5684   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5685   Dali::Quaternion *arg2 = 0 ;
5686   Dali::Vector3 *result = 0 ;
5687
5688   arg1 = (Dali::Vector3 *)jarg1;
5689   arg2 = (Dali::Quaternion *)jarg2;
5690   if (!arg2) {
5691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5692     return 0;
5693   }
5694   {
5695     try {
5696       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5697     } catch (std::out_of_range& e) {
5698       {
5699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (std::exception& e) {
5702       {
5703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5704       };
5705     } catch (...) {
5706       {
5707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5708       };
5709     }
5710   }
5711   jresult = (void *)result;
5712   return jresult;
5713 }
5714
5715
5716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5717   void * jresult ;
5718   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5719   Dali::Vector3 *arg2 = 0 ;
5720   Dali::Vector3 result;
5721
5722   arg1 = (Dali::Vector3 *)jarg1;
5723   arg2 = (Dali::Vector3 *)jarg2;
5724   if (!arg2) {
5725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5726     return 0;
5727   }
5728   {
5729     try {
5730       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5731     } catch (std::out_of_range& e) {
5732       {
5733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5734       };
5735     } catch (std::exception& e) {
5736       {
5737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5738       };
5739     } catch (...) {
5740       {
5741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5742       };
5743     }
5744   }
5745   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5746   return jresult;
5747 }
5748
5749
5750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5751   void * jresult ;
5752   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5753   float arg2 ;
5754   Dali::Vector3 result;
5755
5756   arg1 = (Dali::Vector3 *)jarg1;
5757   arg2 = (float)jarg2;
5758   {
5759     try {
5760       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5761     } catch (std::out_of_range& e) {
5762       {
5763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5764       };
5765     } catch (std::exception& e) {
5766       {
5767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5768       };
5769     } catch (...) {
5770       {
5771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5772       };
5773     }
5774   }
5775   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5781   void * jresult ;
5782   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5783   Dali::Vector3 *arg2 = 0 ;
5784   Dali::Vector3 *result = 0 ;
5785
5786   arg1 = (Dali::Vector3 *)jarg1;
5787   arg2 = (Dali::Vector3 *)jarg2;
5788   if (!arg2) {
5789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5790     return 0;
5791   }
5792   {
5793     try {
5794       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5795     } catch (std::out_of_range& e) {
5796       {
5797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5798       };
5799     } catch (std::exception& e) {
5800       {
5801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5802       };
5803     } catch (...) {
5804       {
5805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5806       };
5807     }
5808   }
5809   jresult = (void *)result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5815   void * jresult ;
5816   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5817   float arg2 ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   arg1 = (Dali::Vector3 *)jarg1;
5821   arg2 = (float)jarg2;
5822   {
5823     try {
5824       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5825     } catch (std::out_of_range& e) {
5826       {
5827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5828       };
5829     } catch (std::exception& e) {
5830       {
5831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5832       };
5833     } catch (...) {
5834       {
5835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5836       };
5837     }
5838   }
5839   jresult = (void *)result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5845   void * jresult ;
5846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5847   Dali::Vector3 result;
5848
5849   arg1 = (Dali::Vector3 *)jarg1;
5850   {
5851     try {
5852       result = ((Dali::Vector3 const *)arg1)->operator -();
5853     } catch (std::out_of_range& e) {
5854       {
5855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (std::exception& e) {
5858       {
5859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (...) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5864       };
5865     }
5866   }
5867   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5868   return jresult;
5869 }
5870
5871
5872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5873   unsigned int jresult ;
5874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5875   Dali::Vector3 *arg2 = 0 ;
5876   bool result;
5877
5878   arg1 = (Dali::Vector3 *)jarg1;
5879   arg2 = (Dali::Vector3 *)jarg2;
5880   if (!arg2) {
5881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5882     return 0;
5883   }
5884   {
5885     try {
5886       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5887     } catch (std::out_of_range& e) {
5888       {
5889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5890       };
5891     } catch (std::exception& e) {
5892       {
5893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5894       };
5895     } catch (...) {
5896       {
5897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5898       };
5899     }
5900   }
5901   jresult = result;
5902   return jresult;
5903 }
5904
5905
5906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5907   unsigned int jresult ;
5908   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5909   Dali::Vector3 *arg2 = 0 ;
5910   bool result;
5911
5912   arg1 = (Dali::Vector3 *)jarg1;
5913   arg2 = (Dali::Vector3 *)jarg2;
5914   if (!arg2) {
5915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5916     return 0;
5917   }
5918   {
5919     try {
5920       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5921     } catch (std::out_of_range& e) {
5922       {
5923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5924       };
5925     } catch (std::exception& e) {
5926       {
5927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5928       };
5929     } catch (...) {
5930       {
5931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5932       };
5933     }
5934   }
5935   jresult = result;
5936   return jresult;
5937 }
5938
5939
5940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5941   float jresult ;
5942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5943   unsigned int arg2 ;
5944   float *result = 0 ;
5945
5946   arg1 = (Dali::Vector3 *)jarg1;
5947   arg2 = (unsigned int)jarg2;
5948   {
5949     try {
5950       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5951     } catch (std::out_of_range& e) {
5952       {
5953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5954       };
5955     } catch (std::exception& e) {
5956       {
5957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5958       };
5959     } catch (...) {
5960       {
5961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5962       };
5963     }
5964   }
5965   jresult = *result;
5966   return jresult;
5967 }
5968
5969
5970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5971   float jresult ;
5972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5973   Dali::Vector3 *arg2 = 0 ;
5974   float result;
5975
5976   arg1 = (Dali::Vector3 *)jarg1;
5977   arg2 = (Dali::Vector3 *)jarg2;
5978   if (!arg2) {
5979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5980     return 0;
5981   }
5982   {
5983     try {
5984       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5985     } catch (std::out_of_range& e) {
5986       {
5987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5988       };
5989     } catch (std::exception& e) {
5990       {
5991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5992       };
5993     } catch (...) {
5994       {
5995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5996       };
5997     }
5998   }
5999   jresult = result;
6000   return jresult;
6001 }
6002
6003
6004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6005   void * jresult ;
6006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6007   Dali::Vector3 *arg2 = 0 ;
6008   Dali::Vector3 result;
6009
6010   arg1 = (Dali::Vector3 *)jarg1;
6011   arg2 = (Dali::Vector3 *)jarg2;
6012   if (!arg2) {
6013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6014     return 0;
6015   }
6016   {
6017     try {
6018       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6019     } catch (std::out_of_range& e) {
6020       {
6021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (std::exception& e) {
6024       {
6025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6034   return jresult;
6035 }
6036
6037
6038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6039   float jresult ;
6040   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6041   float result;
6042
6043   arg1 = (Dali::Vector3 *)jarg1;
6044   {
6045     try {
6046       result = (float)((Dali::Vector3 const *)arg1)->Length();
6047     } catch (std::out_of_range& e) {
6048       {
6049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6050       };
6051     } catch (std::exception& e) {
6052       {
6053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6054       };
6055     } catch (...) {
6056       {
6057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6058       };
6059     }
6060   }
6061   jresult = result;
6062   return jresult;
6063 }
6064
6065
6066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6067   float jresult ;
6068   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6069   float result;
6070
6071   arg1 = (Dali::Vector3 *)jarg1;
6072   {
6073     try {
6074       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6075     } catch (std::out_of_range& e) {
6076       {
6077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6078       };
6079     } catch (std::exception& e) {
6080       {
6081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6082       };
6083     } catch (...) {
6084       {
6085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6086       };
6087     }
6088   }
6089   jresult = result;
6090   return jresult;
6091 }
6092
6093
6094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6095   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6096
6097   arg1 = (Dali::Vector3 *)jarg1;
6098   {
6099     try {
6100       (arg1)->Normalize();
6101     } catch (std::out_of_range& e) {
6102       {
6103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6104       };
6105     } catch (std::exception& e) {
6106       {
6107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6108       };
6109     } catch (...) {
6110       {
6111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6112       };
6113     }
6114   }
6115 }
6116
6117
6118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 *arg3 = 0 ;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return ;
6128   }
6129   arg3 = (Dali::Vector3 *)jarg3;
6130   if (!arg3) {
6131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6132     return ;
6133   }
6134   {
6135     try {
6136       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6144       };
6145     } catch (...) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6148       };
6149     }
6150   }
6151 }
6152
6153
6154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6155   void * jresult ;
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float *result = 0 ;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   {
6161     try {
6162       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6163     } catch (std::out_of_range& e) {
6164       {
6165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (std::exception& e) {
6168       {
6169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (...) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6174       };
6175     }
6176   }
6177   jresult = (void *)result;
6178   return jresult;
6179 }
6180
6181
6182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6183   void * jresult ;
6184   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6185   Dali::Vector2 *result = 0 ;
6186
6187   arg1 = (Dali::Vector3 *)jarg1;
6188   {
6189     try {
6190       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6191     } catch (std::out_of_range& e) {
6192       {
6193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6194       };
6195     } catch (std::exception& e) {
6196       {
6197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6198       };
6199     } catch (...) {
6200       {
6201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6202       };
6203     }
6204   }
6205   jresult = (void *)result;
6206   return jresult;
6207 }
6208
6209
6210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6211   void * jresult ;
6212   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6213   Dali::Vector2 *result = 0 ;
6214
6215   arg1 = (Dali::Vector3 *)jarg1;
6216   {
6217     try {
6218       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6219     } catch (std::out_of_range& e) {
6220       {
6221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6222       };
6223     } catch (std::exception& e) {
6224       {
6225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6226       };
6227     } catch (...) {
6228       {
6229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6230       };
6231     }
6232   }
6233   jresult = (void *)result;
6234   return jresult;
6235 }
6236
6237
6238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6240   float arg2 ;
6241
6242   arg1 = (Dali::Vector3 *)jarg1;
6243   arg2 = (float)jarg2;
6244   if (arg1) (arg1)->x = arg2;
6245 }
6246
6247
6248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6249   float jresult ;
6250   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6251   float result;
6252
6253   arg1 = (Dali::Vector3 *)jarg1;
6254   result = (float) ((arg1)->x);
6255   jresult = result;
6256   return jresult;
6257 }
6258
6259
6260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6261   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6262   float arg2 ;
6263
6264   arg1 = (Dali::Vector3 *)jarg1;
6265   arg2 = (float)jarg2;
6266   if (arg1) (arg1)->width = arg2;
6267 }
6268
6269
6270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6271   float jresult ;
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   float result;
6274
6275   arg1 = (Dali::Vector3 *)jarg1;
6276   result = (float) ((arg1)->width);
6277   jresult = result;
6278   return jresult;
6279 }
6280
6281
6282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6284   float arg2 ;
6285
6286   arg1 = (Dali::Vector3 *)jarg1;
6287   arg2 = (float)jarg2;
6288   if (arg1) (arg1)->r = arg2;
6289 }
6290
6291
6292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6293   float jresult ;
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float result;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   result = (float) ((arg1)->r);
6299   jresult = result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6306   float arg2 ;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (float)jarg2;
6310   if (arg1) (arg1)->y = arg2;
6311 }
6312
6313
6314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6315   float jresult ;
6316   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6317   float result;
6318
6319   arg1 = (Dali::Vector3 *)jarg1;
6320   result = (float) ((arg1)->y);
6321   jresult = result;
6322   return jresult;
6323 }
6324
6325
6326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6327   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6328   float arg2 ;
6329
6330   arg1 = (Dali::Vector3 *)jarg1;
6331   arg2 = (float)jarg2;
6332   if (arg1) (arg1)->height = arg2;
6333 }
6334
6335
6336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6337   float jresult ;
6338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6339   float result;
6340
6341   arg1 = (Dali::Vector3 *)jarg1;
6342   result = (float) ((arg1)->height);
6343   jresult = result;
6344   return jresult;
6345 }
6346
6347
6348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6349   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6350   float arg2 ;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   arg2 = (float)jarg2;
6354   if (arg1) (arg1)->g = arg2;
6355 }
6356
6357
6358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6359   float jresult ;
6360   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6361   float result;
6362
6363   arg1 = (Dali::Vector3 *)jarg1;
6364   result = (float) ((arg1)->g);
6365   jresult = result;
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6371   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6372   float arg2 ;
6373
6374   arg1 = (Dali::Vector3 *)jarg1;
6375   arg2 = (float)jarg2;
6376   if (arg1) (arg1)->z = arg2;
6377 }
6378
6379
6380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6381   float jresult ;
6382   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6383   float result;
6384
6385   arg1 = (Dali::Vector3 *)jarg1;
6386   result = (float) ((arg1)->z);
6387   jresult = result;
6388   return jresult;
6389 }
6390
6391
6392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6393   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6394   float arg2 ;
6395
6396   arg1 = (Dali::Vector3 *)jarg1;
6397   arg2 = (float)jarg2;
6398   if (arg1) (arg1)->depth = arg2;
6399 }
6400
6401
6402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6403   float jresult ;
6404   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6405   float result;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   result = (float) ((arg1)->depth);
6409   jresult = result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6415   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6416   float arg2 ;
6417
6418   arg1 = (Dali::Vector3 *)jarg1;
6419   arg2 = (float)jarg2;
6420   if (arg1) (arg1)->b = arg2;
6421 }
6422
6423
6424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6425   float jresult ;
6426   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6427   float result;
6428
6429   arg1 = (Dali::Vector3 *)jarg1;
6430   result = (float) ((arg1)->b);
6431   jresult = result;
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6437   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6438
6439   arg1 = (Dali::Vector3 *)jarg1;
6440   {
6441     try {
6442       delete arg1;
6443     } catch (std::out_of_range& e) {
6444       {
6445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6446       };
6447     } catch (std::exception& e) {
6448       {
6449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6450       };
6451     } catch (...) {
6452       {
6453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6454       };
6455     }
6456   }
6457 }
6458
6459
6460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6461   void * jresult ;
6462   Dali::Vector3 *arg1 = 0 ;
6463   Dali::Vector3 *arg2 = 0 ;
6464   Dali::Vector3 result;
6465
6466   arg1 = (Dali::Vector3 *)jarg1;
6467   if (!arg1) {
6468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6469     return 0;
6470   }
6471   arg2 = (Dali::Vector3 *)jarg2;
6472   if (!arg2) {
6473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6474     return 0;
6475   }
6476   {
6477     try {
6478       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6479     } catch (std::out_of_range& e) {
6480       {
6481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6482       };
6483     } catch (std::exception& e) {
6484       {
6485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6486       };
6487     } catch (...) {
6488       {
6489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6490       };
6491     }
6492   }
6493   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6494   return jresult;
6495 }
6496
6497
6498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6499   void * jresult ;
6500   Dali::Vector3 *arg1 = 0 ;
6501   Dali::Vector3 *arg2 = 0 ;
6502   Dali::Vector3 result;
6503
6504   arg1 = (Dali::Vector3 *)jarg1;
6505   if (!arg1) {
6506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6507     return 0;
6508   }
6509   arg2 = (Dali::Vector3 *)jarg2;
6510   if (!arg2) {
6511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6512     return 0;
6513   }
6514   {
6515     try {
6516       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6517     } catch (std::out_of_range& e) {
6518       {
6519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6520       };
6521     } catch (std::exception& e) {
6522       {
6523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6524       };
6525     } catch (...) {
6526       {
6527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6528       };
6529     }
6530   }
6531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6532   return jresult;
6533 }
6534
6535
6536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6537   void * jresult ;
6538   Dali::Vector3 *arg1 = 0 ;
6539   float *arg2 = 0 ;
6540   float *arg3 = 0 ;
6541   float temp2 ;
6542   float temp3 ;
6543   Dali::Vector3 result;
6544
6545   arg1 = (Dali::Vector3 *)jarg1;
6546   if (!arg1) {
6547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6548     return 0;
6549   }
6550   temp2 = (float)jarg2;
6551   arg2 = &temp2;
6552   temp3 = (float)jarg3;
6553   arg3 = &temp3;
6554   {
6555     try {
6556       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6557     } catch (std::out_of_range& e) {
6558       {
6559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6560       };
6561     } catch (std::exception& e) {
6562       {
6563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6564       };
6565     } catch (...) {
6566       {
6567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6568       };
6569     }
6570   }
6571   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6572   return jresult;
6573 }
6574
6575
6576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6577   void * jresult ;
6578   Dali::Vector4 *result = 0 ;
6579
6580   {
6581     try {
6582       result = (Dali::Vector4 *)new Dali::Vector4();
6583     } catch (std::out_of_range& e) {
6584       {
6585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6586       };
6587     } catch (std::exception& e) {
6588       {
6589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6590       };
6591     } catch (...) {
6592       {
6593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6594       };
6595     }
6596   }
6597   jresult = (void *)result;
6598   return jresult;
6599 }
6600
6601
6602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6603   void * jresult ;
6604   float arg1 ;
6605   float arg2 ;
6606   float arg3 ;
6607   float arg4 ;
6608   Dali::Vector4 *result = 0 ;
6609
6610   arg1 = (float)jarg1;
6611   arg2 = (float)jarg2;
6612   arg3 = (float)jarg3;
6613   arg4 = (float)jarg4;
6614   {
6615     try {
6616       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6617     } catch (std::out_of_range& e) {
6618       {
6619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (std::exception& e) {
6622       {
6623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631   jresult = (void *)result;
6632   return jresult;
6633 }
6634
6635
6636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6637   void * jresult ;
6638   float *arg1 = (float *) 0 ;
6639   Dali::Vector4 *result = 0 ;
6640
6641   arg1 = jarg1;
6642   {
6643     try {
6644       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6645     } catch (std::out_of_range& e) {
6646       {
6647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6648       };
6649     } catch (std::exception& e) {
6650       {
6651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6652       };
6653     } catch (...) {
6654       {
6655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6656       };
6657     }
6658   }
6659   jresult = (void *)result;
6660
6661
6662   return jresult;
6663 }
6664
6665
6666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6667   void * jresult ;
6668   Dali::Vector2 *arg1 = 0 ;
6669   Dali::Vector4 *result = 0 ;
6670
6671   arg1 = (Dali::Vector2 *)jarg1;
6672   if (!arg1) {
6673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6674     return 0;
6675   }
6676   {
6677     try {
6678       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6679     } catch (std::out_of_range& e) {
6680       {
6681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6682       };
6683     } catch (std::exception& e) {
6684       {
6685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (...) {
6688       {
6689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6690       };
6691     }
6692   }
6693   jresult = (void *)result;
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6699   void * jresult ;
6700   Dali::Vector3 *arg1 = 0 ;
6701   Dali::Vector4 *result = 0 ;
6702
6703   arg1 = (Dali::Vector3 *)jarg1;
6704   if (!arg1) {
6705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6706     return 0;
6707   }
6708   {
6709     try {
6710       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6711     } catch (std::out_of_range& e) {
6712       {
6713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6714       };
6715     } catch (std::exception& e) {
6716       {
6717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (...) {
6720       {
6721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6722       };
6723     }
6724   }
6725   jresult = (void *)result;
6726   return jresult;
6727 }
6728
6729
6730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6731   void * jresult ;
6732   Dali::Vector4 *result = 0 ;
6733
6734   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6735   jresult = (void *)result;
6736   return jresult;
6737 }
6738
6739
6740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6741   void * jresult ;
6742   Dali::Vector4 *result = 0 ;
6743
6744   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6745   jresult = (void *)result;
6746   return jresult;
6747 }
6748
6749
6750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6751   void * jresult ;
6752   Dali::Vector4 *result = 0 ;
6753
6754   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6755   jresult = (void *)result;
6756   return jresult;
6757 }
6758
6759
6760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6761   void * jresult ;
6762   Dali::Vector4 *result = 0 ;
6763
6764   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6765   jresult = (void *)result;
6766   return jresult;
6767 }
6768
6769
6770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6771   void * jresult ;
6772   Dali::Vector4 *result = 0 ;
6773
6774   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6775   jresult = (void *)result;
6776   return jresult;
6777 }
6778
6779
6780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6781   void * jresult ;
6782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6783   float *arg2 = (float *) 0 ;
6784   Dali::Vector4 *result = 0 ;
6785
6786   arg1 = (Dali::Vector4 *)jarg1;
6787   arg2 = jarg2;
6788   {
6789     try {
6790       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6791     } catch (std::out_of_range& e) {
6792       {
6793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6794       };
6795     } catch (std::exception& e) {
6796       {
6797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6798       };
6799     } catch (...) {
6800       {
6801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6802       };
6803     }
6804   }
6805   jresult = (void *)result;
6806
6807
6808   return jresult;
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6813   void * jresult ;
6814   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6815   Dali::Vector2 *arg2 = 0 ;
6816   Dali::Vector4 *result = 0 ;
6817
6818   arg1 = (Dali::Vector4 *)jarg1;
6819   arg2 = (Dali::Vector2 *)jarg2;
6820   if (!arg2) {
6821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6822     return 0;
6823   }
6824   {
6825     try {
6826       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6827     } catch (std::out_of_range& e) {
6828       {
6829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6830       };
6831     } catch (std::exception& e) {
6832       {
6833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6834       };
6835     } catch (...) {
6836       {
6837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6838       };
6839     }
6840   }
6841   jresult = (void *)result;
6842   return jresult;
6843 }
6844
6845
6846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6847   void * jresult ;
6848   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6849   Dali::Vector3 *arg2 = 0 ;
6850   Dali::Vector4 *result = 0 ;
6851
6852   arg1 = (Dali::Vector4 *)jarg1;
6853   arg2 = (Dali::Vector3 *)jarg2;
6854   if (!arg2) {
6855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6856     return 0;
6857   }
6858   {
6859     try {
6860       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6861     } catch (std::out_of_range& e) {
6862       {
6863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6864       };
6865     } catch (std::exception& e) {
6866       {
6867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6868       };
6869     } catch (...) {
6870       {
6871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6872       };
6873     }
6874   }
6875   jresult = (void *)result;
6876   return jresult;
6877 }
6878
6879
6880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6881   void * jresult ;
6882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6883   Dali::Vector4 *arg2 = 0 ;
6884   Dali::Vector4 result;
6885
6886   arg1 = (Dali::Vector4 *)jarg1;
6887   arg2 = (Dali::Vector4 *)jarg2;
6888   if (!arg2) {
6889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6890     return 0;
6891   }
6892   {
6893     try {
6894       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6895     } catch (std::out_of_range& e) {
6896       {
6897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6898       };
6899     } catch (std::exception& e) {
6900       {
6901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6902       };
6903     } catch (...) {
6904       {
6905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6906       };
6907     }
6908   }
6909   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6910   return jresult;
6911 }
6912
6913
6914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6915   void * jresult ;
6916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6917   Dali::Vector4 *arg2 = 0 ;
6918   Dali::Vector4 *result = 0 ;
6919
6920   arg1 = (Dali::Vector4 *)jarg1;
6921   arg2 = (Dali::Vector4 *)jarg2;
6922   if (!arg2) {
6923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6924     return 0;
6925   }
6926   {
6927     try {
6928       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6929     } catch (std::out_of_range& e) {
6930       {
6931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6932       };
6933     } catch (std::exception& e) {
6934       {
6935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6936       };
6937     } catch (...) {
6938       {
6939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6940       };
6941     }
6942   }
6943   jresult = (void *)result;
6944   return jresult;
6945 }
6946
6947
6948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6949   void * jresult ;
6950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6951   Dali::Vector4 *arg2 = 0 ;
6952   Dali::Vector4 result;
6953
6954   arg1 = (Dali::Vector4 *)jarg1;
6955   arg2 = (Dali::Vector4 *)jarg2;
6956   if (!arg2) {
6957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6958     return 0;
6959   }
6960   {
6961     try {
6962       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6963     } catch (std::out_of_range& e) {
6964       {
6965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6966       };
6967     } catch (std::exception& e) {
6968       {
6969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6970       };
6971     } catch (...) {
6972       {
6973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6974       };
6975     }
6976   }
6977   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6978   return jresult;
6979 }
6980
6981
6982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6983   void * jresult ;
6984   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6985   Dali::Vector4 *arg2 = 0 ;
6986   Dali::Vector4 *result = 0 ;
6987
6988   arg1 = (Dali::Vector4 *)jarg1;
6989   arg2 = (Dali::Vector4 *)jarg2;
6990   if (!arg2) {
6991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6992     return 0;
6993   }
6994   {
6995     try {
6996       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6997     } catch (std::out_of_range& e) {
6998       {
6999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7000       };
7001     } catch (std::exception& e) {
7002       {
7003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7004       };
7005     } catch (...) {
7006       {
7007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7008       };
7009     }
7010   }
7011   jresult = (void *)result;
7012   return jresult;
7013 }
7014
7015
7016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7017   void * jresult ;
7018   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7019   Dali::Vector4 *arg2 = 0 ;
7020   Dali::Vector4 result;
7021
7022   arg1 = (Dali::Vector4 *)jarg1;
7023   arg2 = (Dali::Vector4 *)jarg2;
7024   if (!arg2) {
7025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7026     return 0;
7027   }
7028   {
7029     try {
7030       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7031     } catch (std::out_of_range& e) {
7032       {
7033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7034       };
7035     } catch (std::exception& e) {
7036       {
7037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7038       };
7039     } catch (...) {
7040       {
7041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7042       };
7043     }
7044   }
7045   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7046   return jresult;
7047 }
7048
7049
7050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7051   void * jresult ;
7052   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7053   float arg2 ;
7054   Dali::Vector4 result;
7055
7056   arg1 = (Dali::Vector4 *)jarg1;
7057   arg2 = (float)jarg2;
7058   {
7059     try {
7060       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7061     } catch (std::out_of_range& e) {
7062       {
7063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7064       };
7065     } catch (std::exception& e) {
7066       {
7067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7068       };
7069     } catch (...) {
7070       {
7071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7072       };
7073     }
7074   }
7075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7076   return jresult;
7077 }
7078
7079
7080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7081   void * jresult ;
7082   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7083   Dali::Vector4 *arg2 = 0 ;
7084   Dali::Vector4 *result = 0 ;
7085
7086   arg1 = (Dali::Vector4 *)jarg1;
7087   arg2 = (Dali::Vector4 *)jarg2;
7088   if (!arg2) {
7089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7090     return 0;
7091   }
7092   {
7093     try {
7094       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7095     } catch (std::out_of_range& e) {
7096       {
7097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7098       };
7099     } catch (std::exception& e) {
7100       {
7101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7102       };
7103     } catch (...) {
7104       {
7105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7106       };
7107     }
7108   }
7109   jresult = (void *)result;
7110   return jresult;
7111 }
7112
7113
7114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7115   void * jresult ;
7116   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7117   float arg2 ;
7118   Dali::Vector4 *result = 0 ;
7119
7120   arg1 = (Dali::Vector4 *)jarg1;
7121   arg2 = (float)jarg2;
7122   {
7123     try {
7124       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7125     } catch (std::out_of_range& e) {
7126       {
7127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7128       };
7129     } catch (std::exception& e) {
7130       {
7131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7132       };
7133     } catch (...) {
7134       {
7135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7136       };
7137     }
7138   }
7139   jresult = (void *)result;
7140   return jresult;
7141 }
7142
7143
7144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7145   void * jresult ;
7146   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7147   Dali::Vector4 *arg2 = 0 ;
7148   Dali::Vector4 result;
7149
7150   arg1 = (Dali::Vector4 *)jarg1;
7151   arg2 = (Dali::Vector4 *)jarg2;
7152   if (!arg2) {
7153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7154     return 0;
7155   }
7156   {
7157     try {
7158       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7159     } catch (std::out_of_range& e) {
7160       {
7161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7162       };
7163     } catch (std::exception& e) {
7164       {
7165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7166       };
7167     } catch (...) {
7168       {
7169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7170       };
7171     }
7172   }
7173   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7174   return jresult;
7175 }
7176
7177
7178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7179   void * jresult ;
7180   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7181   float arg2 ;
7182   Dali::Vector4 result;
7183
7184   arg1 = (Dali::Vector4 *)jarg1;
7185   arg2 = (float)jarg2;
7186   {
7187     try {
7188       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7189     } catch (std::out_of_range& e) {
7190       {
7191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7192       };
7193     } catch (std::exception& e) {
7194       {
7195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7196       };
7197     } catch (...) {
7198       {
7199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7200       };
7201     }
7202   }
7203   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7204   return jresult;
7205 }
7206
7207
7208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7209   void * jresult ;
7210   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7211   Dali::Vector4 *arg2 = 0 ;
7212   Dali::Vector4 *result = 0 ;
7213
7214   arg1 = (Dali::Vector4 *)jarg1;
7215   arg2 = (Dali::Vector4 *)jarg2;
7216   if (!arg2) {
7217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7218     return 0;
7219   }
7220   {
7221     try {
7222       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7223     } catch (std::out_of_range& e) {
7224       {
7225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7226       };
7227     } catch (std::exception& e) {
7228       {
7229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7230       };
7231     } catch (...) {
7232       {
7233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7234       };
7235     }
7236   }
7237   jresult = (void *)result;
7238   return jresult;
7239 }
7240
7241
7242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7243   void * jresult ;
7244   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7245   float arg2 ;
7246   Dali::Vector4 *result = 0 ;
7247
7248   arg1 = (Dali::Vector4 *)jarg1;
7249   arg2 = (float)jarg2;
7250   {
7251     try {
7252       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7253     } catch (std::out_of_range& e) {
7254       {
7255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7256       };
7257     } catch (std::exception& e) {
7258       {
7259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7260       };
7261     } catch (...) {
7262       {
7263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7264       };
7265     }
7266   }
7267   jresult = (void *)result;
7268   return jresult;
7269 }
7270
7271
7272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7273   void * jresult ;
7274   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7275   Dali::Vector4 result;
7276
7277   arg1 = (Dali::Vector4 *)jarg1;
7278   {
7279     try {
7280       result = ((Dali::Vector4 const *)arg1)->operator -();
7281     } catch (std::out_of_range& e) {
7282       {
7283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7284       };
7285     } catch (std::exception& e) {
7286       {
7287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7288       };
7289     } catch (...) {
7290       {
7291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7292       };
7293     }
7294   }
7295   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7301   unsigned int jresult ;
7302   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7303   Dali::Vector4 *arg2 = 0 ;
7304   bool result;
7305
7306   arg1 = (Dali::Vector4 *)jarg1;
7307   arg2 = (Dali::Vector4 *)jarg2;
7308   if (!arg2) {
7309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7310     return 0;
7311   }
7312   {
7313     try {
7314       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (...) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7326       };
7327     }
7328   }
7329   jresult = result;
7330   return jresult;
7331 }
7332
7333
7334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7335   unsigned int jresult ;
7336   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7337   Dali::Vector4 *arg2 = 0 ;
7338   bool result;
7339
7340   arg1 = (Dali::Vector4 *)jarg1;
7341   arg2 = (Dali::Vector4 *)jarg2;
7342   if (!arg2) {
7343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7344     return 0;
7345   }
7346   {
7347     try {
7348       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7349     } catch (std::out_of_range& e) {
7350       {
7351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (std::exception& e) {
7354       {
7355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7356       };
7357     } catch (...) {
7358       {
7359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7360       };
7361     }
7362   }
7363   jresult = result;
7364   return jresult;
7365 }
7366
7367
7368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7369   float jresult ;
7370   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7371   unsigned int arg2 ;
7372   float *result = 0 ;
7373
7374   arg1 = (Dali::Vector4 *)jarg1;
7375   arg2 = (unsigned int)jarg2;
7376   {
7377     try {
7378       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7379     } catch (std::out_of_range& e) {
7380       {
7381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (std::exception& e) {
7384       {
7385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7386       };
7387     } catch (...) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7390       };
7391     }
7392   }
7393   jresult = *result;
7394   return jresult;
7395 }
7396
7397
7398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7399   float jresult ;
7400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7401   Dali::Vector3 *arg2 = 0 ;
7402   float result;
7403
7404   arg1 = (Dali::Vector4 *)jarg1;
7405   arg2 = (Dali::Vector3 *)jarg2;
7406   if (!arg2) {
7407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7408     return 0;
7409   }
7410   {
7411     try {
7412       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7413     } catch (std::out_of_range& e) {
7414       {
7415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7416       };
7417     } catch (std::exception& e) {
7418       {
7419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7420       };
7421     } catch (...) {
7422       {
7423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7424       };
7425     }
7426   }
7427   jresult = result;
7428   return jresult;
7429 }
7430
7431
7432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7433   float jresult ;
7434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7435   Dali::Vector4 *arg2 = 0 ;
7436   float result;
7437
7438   arg1 = (Dali::Vector4 *)jarg1;
7439   arg2 = (Dali::Vector4 *)jarg2;
7440   if (!arg2) {
7441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7442     return 0;
7443   }
7444   {
7445     try {
7446       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7447     } catch (std::out_of_range& e) {
7448       {
7449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7450       };
7451     } catch (std::exception& e) {
7452       {
7453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7454       };
7455     } catch (...) {
7456       {
7457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7458       };
7459     }
7460   }
7461   jresult = result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7467   float jresult ;
7468   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7469   Dali::Vector4 *arg2 = 0 ;
7470   float result;
7471
7472   arg1 = (Dali::Vector4 *)jarg1;
7473   arg2 = (Dali::Vector4 *)jarg2;
7474   if (!arg2) {
7475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7476     return 0;
7477   }
7478   {
7479     try {
7480       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7481     } catch (std::out_of_range& e) {
7482       {
7483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7484       };
7485     } catch (std::exception& e) {
7486       {
7487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7488       };
7489     } catch (...) {
7490       {
7491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7492       };
7493     }
7494   }
7495   jresult = result;
7496   return jresult;
7497 }
7498
7499
7500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7501   void * jresult ;
7502   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7503   Dali::Vector4 *arg2 = 0 ;
7504   Dali::Vector4 result;
7505
7506   arg1 = (Dali::Vector4 *)jarg1;
7507   arg2 = (Dali::Vector4 *)jarg2;
7508   if (!arg2) {
7509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7510     return 0;
7511   }
7512   {
7513     try {
7514       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7515     } catch (std::out_of_range& e) {
7516       {
7517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7518       };
7519     } catch (std::exception& e) {
7520       {
7521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7522       };
7523     } catch (...) {
7524       {
7525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7526       };
7527     }
7528   }
7529   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7530   return jresult;
7531 }
7532
7533
7534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7535   float jresult ;
7536   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7537   float result;
7538
7539   arg1 = (Dali::Vector4 *)jarg1;
7540   {
7541     try {
7542       result = (float)((Dali::Vector4 const *)arg1)->Length();
7543     } catch (std::out_of_range& e) {
7544       {
7545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7546       };
7547     } catch (std::exception& e) {
7548       {
7549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7550       };
7551     } catch (...) {
7552       {
7553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7554       };
7555     }
7556   }
7557   jresult = result;
7558   return jresult;
7559 }
7560
7561
7562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7563   float jresult ;
7564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7565   float result;
7566
7567   arg1 = (Dali::Vector4 *)jarg1;
7568   {
7569     try {
7570       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7571     } catch (std::out_of_range& e) {
7572       {
7573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7574       };
7575     } catch (std::exception& e) {
7576       {
7577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7578       };
7579     } catch (...) {
7580       {
7581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7582       };
7583     }
7584   }
7585   jresult = result;
7586   return jresult;
7587 }
7588
7589
7590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7591   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7592
7593   arg1 = (Dali::Vector4 *)jarg1;
7594   {
7595     try {
7596       (arg1)->Normalize();
7597     } catch (std::out_of_range& e) {
7598       {
7599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7600       };
7601     } catch (std::exception& e) {
7602       {
7603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7604       };
7605     } catch (...) {
7606       {
7607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7608       };
7609     }
7610   }
7611 }
7612
7613
7614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 *arg3 = 0 ;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return ;
7624   }
7625   arg3 = (Dali::Vector4 *)jarg3;
7626   if (!arg3) {
7627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7628     return ;
7629   }
7630   {
7631     try {
7632       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7633     } catch (std::out_of_range& e) {
7634       {
7635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7636       };
7637     } catch (std::exception& e) {
7638       {
7639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7640       };
7641     } catch (...) {
7642       {
7643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7644       };
7645     }
7646   }
7647 }
7648
7649
7650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7651   void * jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   float *result = 0 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   {
7657     try {
7658       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7659     } catch (std::out_of_range& e) {
7660       {
7661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (std::exception& e) {
7664       {
7665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (...) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7670       };
7671     }
7672   }
7673   jresult = (void *)result;
7674   return jresult;
7675 }
7676
7677
7678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7679   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7680   float arg2 ;
7681
7682   arg1 = (Dali::Vector4 *)jarg1;
7683   arg2 = (float)jarg2;
7684   if (arg1) (arg1)->x = arg2;
7685 }
7686
7687
7688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7689   float jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   float result;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   result = (float) ((arg1)->x);
7695   jresult = result;
7696   return jresult;
7697 }
7698
7699
7700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7702   float arg2 ;
7703
7704   arg1 = (Dali::Vector4 *)jarg1;
7705   arg2 = (float)jarg2;
7706   if (arg1) (arg1)->r = arg2;
7707 }
7708
7709
7710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7711   float jresult ;
7712   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7713   float result;
7714
7715   arg1 = (Dali::Vector4 *)jarg1;
7716   result = (float) ((arg1)->r);
7717   jresult = result;
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7723   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7724   float arg2 ;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   arg2 = (float)jarg2;
7728   if (arg1) (arg1)->s = arg2;
7729 }
7730
7731
7732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7733   float jresult ;
7734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7735   float result;
7736
7737   arg1 = (Dali::Vector4 *)jarg1;
7738   result = (float) ((arg1)->s);
7739   jresult = result;
7740   return jresult;
7741 }
7742
7743
7744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7746   float arg2 ;
7747
7748   arg1 = (Dali::Vector4 *)jarg1;
7749   arg2 = (float)jarg2;
7750   if (arg1) (arg1)->y = arg2;
7751 }
7752
7753
7754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7755   float jresult ;
7756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7757   float result;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   result = (float) ((arg1)->y);
7761   jresult = result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   float arg2 ;
7769
7770   arg1 = (Dali::Vector4 *)jarg1;
7771   arg2 = (float)jarg2;
7772   if (arg1) (arg1)->g = arg2;
7773 }
7774
7775
7776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7777   float jresult ;
7778   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7779   float result;
7780
7781   arg1 = (Dali::Vector4 *)jarg1;
7782   result = (float) ((arg1)->g);
7783   jresult = result;
7784   return jresult;
7785 }
7786
7787
7788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7789   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7790   float arg2 ;
7791
7792   arg1 = (Dali::Vector4 *)jarg1;
7793   arg2 = (float)jarg2;
7794   if (arg1) (arg1)->t = arg2;
7795 }
7796
7797
7798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7799   float jresult ;
7800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7801   float result;
7802
7803   arg1 = (Dali::Vector4 *)jarg1;
7804   result = (float) ((arg1)->t);
7805   jresult = result;
7806   return jresult;
7807 }
7808
7809
7810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7812   float arg2 ;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   if (arg1) (arg1)->z = arg2;
7817 }
7818
7819
7820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7821   float jresult ;
7822   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7823   float result;
7824
7825   arg1 = (Dali::Vector4 *)jarg1;
7826   result = (float) ((arg1)->z);
7827   jresult = result;
7828   return jresult;
7829 }
7830
7831
7832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float arg2 ;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   arg2 = (float)jarg2;
7838   if (arg1) (arg1)->b = arg2;
7839 }
7840
7841
7842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7843   float jresult ;
7844   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7845   float result;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   result = (float) ((arg1)->b);
7849   jresult = result;
7850   return jresult;
7851 }
7852
7853
7854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7855   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7856   float arg2 ;
7857
7858   arg1 = (Dali::Vector4 *)jarg1;
7859   arg2 = (float)jarg2;
7860   if (arg1) (arg1)->p = arg2;
7861 }
7862
7863
7864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7865   float jresult ;
7866   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7867   float result;
7868
7869   arg1 = (Dali::Vector4 *)jarg1;
7870   result = (float) ((arg1)->p);
7871   jresult = result;
7872   return jresult;
7873 }
7874
7875
7876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7877   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7878   float arg2 ;
7879
7880   arg1 = (Dali::Vector4 *)jarg1;
7881   arg2 = (float)jarg2;
7882   if (arg1) (arg1)->w = arg2;
7883 }
7884
7885
7886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7887   float jresult ;
7888   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7889   float result;
7890
7891   arg1 = (Dali::Vector4 *)jarg1;
7892   result = (float) ((arg1)->w);
7893   jresult = result;
7894   return jresult;
7895 }
7896
7897
7898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7899   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7900   float arg2 ;
7901
7902   arg1 = (Dali::Vector4 *)jarg1;
7903   arg2 = (float)jarg2;
7904   if (arg1) (arg1)->a = arg2;
7905 }
7906
7907
7908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7909   float jresult ;
7910   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7911   float result;
7912
7913   arg1 = (Dali::Vector4 *)jarg1;
7914   result = (float) ((arg1)->a);
7915   jresult = result;
7916   return jresult;
7917 }
7918
7919
7920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7921   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7922   float arg2 ;
7923
7924   arg1 = (Dali::Vector4 *)jarg1;
7925   arg2 = (float)jarg2;
7926   if (arg1) (arg1)->q = arg2;
7927 }
7928
7929
7930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7931   float jresult ;
7932   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7933   float result;
7934
7935   arg1 = (Dali::Vector4 *)jarg1;
7936   result = (float) ((arg1)->q);
7937   jresult = result;
7938   return jresult;
7939 }
7940
7941
7942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7943   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7944
7945   arg1 = (Dali::Vector4 *)jarg1;
7946   {
7947     try {
7948       delete arg1;
7949     } catch (std::out_of_range& e) {
7950       {
7951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7952       };
7953     } catch (std::exception& e) {
7954       {
7955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7956       };
7957     } catch (...) {
7958       {
7959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7960       };
7961     }
7962   }
7963 }
7964
7965
7966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7967   void * jresult ;
7968   Dali::Vector4 *arg1 = 0 ;
7969   Dali::Vector4 *arg2 = 0 ;
7970   Dali::Vector4 result;
7971
7972   arg1 = (Dali::Vector4 *)jarg1;
7973   if (!arg1) {
7974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7975     return 0;
7976   }
7977   arg2 = (Dali::Vector4 *)jarg2;
7978   if (!arg2) {
7979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7980     return 0;
7981   }
7982   {
7983     try {
7984       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7985     } catch (std::out_of_range& e) {
7986       {
7987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7988       };
7989     } catch (std::exception& e) {
7990       {
7991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7992       };
7993     } catch (...) {
7994       {
7995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7996       };
7997     }
7998   }
7999   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8000   return jresult;
8001 }
8002
8003
8004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8005   void * jresult ;
8006   Dali::Vector4 *arg1 = 0 ;
8007   Dali::Vector4 *arg2 = 0 ;
8008   Dali::Vector4 result;
8009
8010   arg1 = (Dali::Vector4 *)jarg1;
8011   if (!arg1) {
8012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8013     return 0;
8014   }
8015   arg2 = (Dali::Vector4 *)jarg2;
8016   if (!arg2) {
8017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8018     return 0;
8019   }
8020   {
8021     try {
8022       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8023     } catch (std::out_of_range& e) {
8024       {
8025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8026       };
8027     } catch (std::exception& e) {
8028       {
8029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8030       };
8031     } catch (...) {
8032       {
8033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8034       };
8035     }
8036   }
8037   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8038   return jresult;
8039 }
8040
8041
8042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8043   void * jresult ;
8044   Dali::Vector4 *arg1 = 0 ;
8045   float *arg2 = 0 ;
8046   float *arg3 = 0 ;
8047   float temp2 ;
8048   float temp3 ;
8049   Dali::Vector4 result;
8050
8051   arg1 = (Dali::Vector4 *)jarg1;
8052   if (!arg1) {
8053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8054     return 0;
8055   }
8056   temp2 = (float)jarg2;
8057   arg2 = &temp2;
8058   temp3 = (float)jarg3;
8059   arg3 = &temp3;
8060   {
8061     try {
8062       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8063     } catch (std::out_of_range& e) {
8064       {
8065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8066       };
8067     } catch (std::exception& e) {
8068       {
8069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8070       };
8071     } catch (...) {
8072       {
8073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8074       };
8075     }
8076   }
8077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8078   return jresult;
8079 }
8080
8081
8082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8083   void * jresult ;
8084   Dali::Uint16Pair *result = 0 ;
8085
8086   {
8087     try {
8088       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8089     } catch (std::out_of_range& e) {
8090       {
8091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8092       };
8093     } catch (std::exception& e) {
8094       {
8095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8096       };
8097     } catch (...) {
8098       {
8099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8100       };
8101     }
8102   }
8103   jresult = (void *)result;
8104   return jresult;
8105 }
8106
8107
8108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8109   void * jresult ;
8110   uint32_t arg1 ;
8111   uint32_t arg2 ;
8112   Dali::Uint16Pair *result = 0 ;
8113
8114   arg1 = (uint32_t)jarg1;
8115   arg2 = (uint32_t)jarg2;
8116   {
8117     try {
8118       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8119     } catch (std::out_of_range& e) {
8120       {
8121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8122       };
8123     } catch (std::exception& e) {
8124       {
8125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (...) {
8128       {
8129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8130       };
8131     }
8132   }
8133   jresult = (void *)result;
8134   return jresult;
8135 }
8136
8137
8138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8139   void * jresult ;
8140   Dali::Uint16Pair *arg1 = 0 ;
8141   Dali::Uint16Pair *result = 0 ;
8142
8143   arg1 = (Dali::Uint16Pair *)jarg1;
8144   if (!arg1) {
8145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8146     return 0;
8147   }
8148   {
8149     try {
8150       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8151     } catch (std::out_of_range& e) {
8152       {
8153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8154       };
8155     } catch (std::exception& e) {
8156       {
8157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8158       };
8159     } catch (...) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8162       };
8163     }
8164   }
8165   jresult = (void *)result;
8166   return jresult;
8167 }
8168
8169
8170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8171   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8172   uint16_t arg2 ;
8173
8174   arg1 = (Dali::Uint16Pair *)jarg1;
8175   arg2 = (uint16_t)jarg2;
8176   {
8177     try {
8178       (arg1)->SetWidth(arg2);
8179     } catch (std::out_of_range& e) {
8180       {
8181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8182       };
8183     } catch (std::exception& e) {
8184       {
8185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8186       };
8187     } catch (...) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8190       };
8191     }
8192   }
8193 }
8194
8195
8196 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8197   unsigned short jresult ;
8198   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8199   uint16_t result;
8200
8201   arg1 = (Dali::Uint16Pair *)jarg1;
8202   {
8203     try {
8204       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8205     } catch (std::out_of_range& e) {
8206       {
8207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8208       };
8209     } catch (std::exception& e) {
8210       {
8211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8212       };
8213     } catch (...) {
8214       {
8215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8216       };
8217     }
8218   }
8219   jresult = result;
8220   return jresult;
8221 }
8222
8223
8224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8225   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8226   uint16_t arg2 ;
8227
8228   arg1 = (Dali::Uint16Pair *)jarg1;
8229   arg2 = (uint16_t)jarg2;
8230   {
8231     try {
8232       (arg1)->SetHeight(arg2);
8233     } catch (std::out_of_range& e) {
8234       {
8235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8236       };
8237     } catch (std::exception& e) {
8238       {
8239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8240       };
8241     } catch (...) {
8242       {
8243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8244       };
8245     }
8246   }
8247 }
8248
8249
8250 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8251   unsigned short jresult ;
8252   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8253   uint16_t result;
8254
8255   arg1 = (Dali::Uint16Pair *)jarg1;
8256   {
8257     try {
8258       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8259     } catch (std::out_of_range& e) {
8260       {
8261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (std::exception& e) {
8264       {
8265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (...) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8270       };
8271     }
8272   }
8273   jresult = result;
8274   return jresult;
8275 }
8276
8277
8278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8279   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8280   uint16_t arg2 ;
8281
8282   arg1 = (Dali::Uint16Pair *)jarg1;
8283   arg2 = (uint16_t)jarg2;
8284   {
8285     try {
8286       (arg1)->SetX(arg2);
8287     } catch (std::out_of_range& e) {
8288       {
8289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8290       };
8291     } catch (std::exception& e) {
8292       {
8293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8294       };
8295     } catch (...) {
8296       {
8297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8298       };
8299     }
8300   }
8301 }
8302
8303
8304 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8305   unsigned short jresult ;
8306   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8307   uint16_t result;
8308
8309   arg1 = (Dali::Uint16Pair *)jarg1;
8310   {
8311     try {
8312       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8313     } catch (std::out_of_range& e) {
8314       {
8315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8316       };
8317     } catch (std::exception& e) {
8318       {
8319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8320       };
8321     } catch (...) {
8322       {
8323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8324       };
8325     }
8326   }
8327   jresult = result;
8328   return jresult;
8329 }
8330
8331
8332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8333   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8334   uint16_t arg2 ;
8335
8336   arg1 = (Dali::Uint16Pair *)jarg1;
8337   arg2 = (uint16_t)jarg2;
8338   {
8339     try {
8340       (arg1)->SetY(arg2);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8348       };
8349     } catch (...) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8352       };
8353     }
8354   }
8355 }
8356
8357
8358 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8359   unsigned short jresult ;
8360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8361   uint16_t result;
8362
8363   arg1 = (Dali::Uint16Pair *)jarg1;
8364   {
8365     try {
8366       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8367     } catch (std::out_of_range& e) {
8368       {
8369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8370       };
8371     } catch (std::exception& e) {
8372       {
8373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8374       };
8375     } catch (...) {
8376       {
8377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8378       };
8379     }
8380   }
8381   jresult = result;
8382   return jresult;
8383 }
8384
8385
8386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8387   void * jresult ;
8388   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8389   Dali::Uint16Pair *arg2 = 0 ;
8390   Dali::Uint16Pair *result = 0 ;
8391
8392   arg1 = (Dali::Uint16Pair *)jarg1;
8393   arg2 = (Dali::Uint16Pair *)jarg2;
8394   if (!arg2) {
8395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8396     return 0;
8397   }
8398   {
8399     try {
8400       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8401     } catch (std::out_of_range& e) {
8402       {
8403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8404       };
8405     } catch (std::exception& e) {
8406       {
8407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8408       };
8409     } catch (...) {
8410       {
8411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8412       };
8413     }
8414   }
8415   jresult = (void *)result;
8416   return jresult;
8417 }
8418
8419
8420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8421   unsigned int jresult ;
8422   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8423   Dali::Uint16Pair *arg2 = 0 ;
8424   bool result;
8425
8426   arg1 = (Dali::Uint16Pair *)jarg1;
8427   arg2 = (Dali::Uint16Pair *)jarg2;
8428   if (!arg2) {
8429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8430     return 0;
8431   }
8432   {
8433     try {
8434       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8435     } catch (std::out_of_range& e) {
8436       {
8437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8438       };
8439     } catch (std::exception& e) {
8440       {
8441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8442       };
8443     } catch (...) {
8444       {
8445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8446       };
8447     }
8448   }
8449   jresult = result;
8450   return jresult;
8451 }
8452
8453
8454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8455   unsigned int jresult ;
8456   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8457   Dali::Uint16Pair *arg2 = 0 ;
8458   bool result;
8459
8460   arg1 = (Dali::Uint16Pair *)jarg1;
8461   arg2 = (Dali::Uint16Pair *)jarg2;
8462   if (!arg2) {
8463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8464     return 0;
8465   }
8466   {
8467     try {
8468       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8469     } catch (std::out_of_range& e) {
8470       {
8471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8472       };
8473     } catch (std::exception& e) {
8474       {
8475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8480       };
8481     }
8482   }
8483   jresult = result;
8484   return jresult;
8485 }
8486
8487
8488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8489   unsigned int jresult ;
8490   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8491   Dali::Uint16Pair *arg2 = 0 ;
8492   bool result;
8493
8494   arg1 = (Dali::Uint16Pair *)jarg1;
8495   arg2 = (Dali::Uint16Pair *)jarg2;
8496   if (!arg2) {
8497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8498     return 0;
8499   }
8500   {
8501     try {
8502       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8503     } catch (std::out_of_range& e) {
8504       {
8505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8506       };
8507     } catch (std::exception& e) {
8508       {
8509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8510       };
8511     } catch (...) {
8512       {
8513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8514       };
8515     }
8516   }
8517   jresult = result;
8518   return jresult;
8519 }
8520
8521
8522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8523   unsigned int jresult ;
8524   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8525   Dali::Uint16Pair *arg2 = 0 ;
8526   bool result;
8527
8528   arg1 = (Dali::Uint16Pair *)jarg1;
8529   arg2 = (Dali::Uint16Pair *)jarg2;
8530   if (!arg2) {
8531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8532     return 0;
8533   }
8534   {
8535     try {
8536       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8537     } catch (std::out_of_range& e) {
8538       {
8539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8540       };
8541     } catch (std::exception& e) {
8542       {
8543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8544       };
8545     } catch (...) {
8546       {
8547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8548       };
8549     }
8550   }
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8557   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8558
8559   arg1 = (Dali::Uint16Pair *)jarg1;
8560   {
8561     try {
8562       delete arg1;
8563     } catch (std::out_of_range& e) {
8564       {
8565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8566       };
8567     } catch (std::exception& e) {
8568       {
8569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8570       };
8571     } catch (...) {
8572       {
8573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8574       };
8575     }
8576   }
8577 }
8578
8579
8580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8581   void * jresult ;
8582   Dali::Degree *result = 0 ;
8583
8584   {
8585     try {
8586       result = (Dali::Degree *)new Dali::Degree();
8587     } catch (std::out_of_range& e) {
8588       {
8589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8590       };
8591     } catch (std::exception& e) {
8592       {
8593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8594       };
8595     } catch (...) {
8596       {
8597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8598       };
8599     }
8600   }
8601   jresult = (void *)result;
8602   return jresult;
8603 }
8604
8605
8606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8607   void * jresult ;
8608   float arg1 ;
8609   Dali::Degree *result = 0 ;
8610
8611   arg1 = (float)jarg1;
8612   {
8613     try {
8614       result = (Dali::Degree *)new Dali::Degree(arg1);
8615     } catch (std::out_of_range& e) {
8616       {
8617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8618       };
8619     } catch (std::exception& e) {
8620       {
8621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8622       };
8623     } catch (...) {
8624       {
8625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8626       };
8627     }
8628   }
8629   jresult = (void *)result;
8630   return jresult;
8631 }
8632
8633
8634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8635   void * jresult ;
8636   Dali::Radian arg1 ;
8637   Dali::Radian *argp1 ;
8638   Dali::Degree *result = 0 ;
8639
8640   argp1 = (Dali::Radian *)jarg1;
8641   if (!argp1) {
8642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8643     return 0;
8644   }
8645   arg1 = *argp1;
8646   {
8647     try {
8648       result = (Dali::Degree *)new Dali::Degree(arg1);
8649     } catch (std::out_of_range& e) {
8650       {
8651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8652       };
8653     } catch (std::exception& e) {
8654       {
8655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8656       };
8657     } catch (...) {
8658       {
8659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8660       };
8661     }
8662   }
8663   jresult = (void *)result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Degree *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->degree = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Degree *)jarg1;
8684   result = (float) ((arg1)->degree);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8691   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8692
8693   arg1 = (Dali::Degree *)jarg1;
8694   {
8695     try {
8696       delete arg1;
8697     } catch (std::out_of_range& e) {
8698       {
8699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8700       };
8701     } catch (std::exception& e) {
8702       {
8703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8704       };
8705     } catch (...) {
8706       {
8707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8708       };
8709     }
8710   }
8711 }
8712
8713
8714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8715   void * jresult ;
8716   Dali::Radian *result = 0 ;
8717
8718   result = (Dali::Radian *)&Dali::ANGLE_360;
8719   jresult = (void *)result;
8720   return jresult;
8721 }
8722
8723
8724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8725   void * jresult ;
8726   Dali::Radian *result = 0 ;
8727
8728   result = (Dali::Radian *)&Dali::ANGLE_315;
8729   jresult = (void *)result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8735   void * jresult ;
8736   Dali::Radian *result = 0 ;
8737
8738   result = (Dali::Radian *)&Dali::ANGLE_270;
8739   jresult = (void *)result;
8740   return jresult;
8741 }
8742
8743
8744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8745   void * jresult ;
8746   Dali::Radian *result = 0 ;
8747
8748   result = (Dali::Radian *)&Dali::ANGLE_225;
8749   jresult = (void *)result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8755   void * jresult ;
8756   Dali::Radian *result = 0 ;
8757
8758   result = (Dali::Radian *)&Dali::ANGLE_180;
8759   jresult = (void *)result;
8760   return jresult;
8761 }
8762
8763
8764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8765   void * jresult ;
8766   Dali::Radian *result = 0 ;
8767
8768   result = (Dali::Radian *)&Dali::ANGLE_135;
8769   jresult = (void *)result;
8770   return jresult;
8771 }
8772
8773
8774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8775   void * jresult ;
8776   Dali::Radian *result = 0 ;
8777
8778   result = (Dali::Radian *)&Dali::ANGLE_120;
8779   jresult = (void *)result;
8780   return jresult;
8781 }
8782
8783
8784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8785   void * jresult ;
8786   Dali::Radian *result = 0 ;
8787
8788   result = (Dali::Radian *)&Dali::ANGLE_90;
8789   jresult = (void *)result;
8790   return jresult;
8791 }
8792
8793
8794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8795   void * jresult ;
8796   Dali::Radian *result = 0 ;
8797
8798   result = (Dali::Radian *)&Dali::ANGLE_60;
8799   jresult = (void *)result;
8800   return jresult;
8801 }
8802
8803
8804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8805   void * jresult ;
8806   Dali::Radian *result = 0 ;
8807
8808   result = (Dali::Radian *)&Dali::ANGLE_45;
8809   jresult = (void *)result;
8810   return jresult;
8811 }
8812
8813
8814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8815   void * jresult ;
8816   Dali::Radian *result = 0 ;
8817
8818   result = (Dali::Radian *)&Dali::ANGLE_30;
8819   jresult = (void *)result;
8820   return jresult;
8821 }
8822
8823
8824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8825   void * jresult ;
8826   Dali::Radian *result = 0 ;
8827
8828   result = (Dali::Radian *)&Dali::ANGLE_0;
8829   jresult = (void *)result;
8830   return jresult;
8831 }
8832
8833
8834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8835   unsigned int jresult ;
8836   Dali::Degree *arg1 = 0 ;
8837   Dali::Degree *arg2 = 0 ;
8838   bool result;
8839
8840   arg1 = (Dali::Degree *)jarg1;
8841   if (!arg1) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8843     return 0;
8844   }
8845   arg2 = (Dali::Degree *)jarg2;
8846   if (!arg2) {
8847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8848     return 0;
8849   }
8850   {
8851     try {
8852       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8853     } catch (std::out_of_range& e) {
8854       {
8855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8856       };
8857     } catch (std::exception& e) {
8858       {
8859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8860       };
8861     } catch (...) {
8862       {
8863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8864       };
8865     }
8866   }
8867   jresult = result;
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8873   unsigned int jresult ;
8874   Dali::Degree *arg1 = 0 ;
8875   Dali::Degree *arg2 = 0 ;
8876   bool result;
8877
8878   arg1 = (Dali::Degree *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Degree *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (...) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8902       };
8903     }
8904   }
8905   jresult = result;
8906   return jresult;
8907 }
8908
8909
8910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8911   void * jresult ;
8912   Dali::Degree arg1 ;
8913   float arg2 ;
8914   float arg3 ;
8915   Dali::Degree *argp1 ;
8916   Dali::Degree result;
8917
8918   argp1 = (Dali::Degree *)jarg1;
8919   if (!argp1) {
8920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8921     return 0;
8922   }
8923   arg1 = *argp1;
8924   arg2 = (float)jarg2;
8925   arg3 = (float)jarg3;
8926   {
8927     try {
8928       result = Dali::Clamp(arg1,arg2,arg3);
8929     } catch (std::out_of_range& e) {
8930       {
8931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8932       };
8933     } catch (std::exception& e) {
8934       {
8935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (...) {
8938       {
8939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8940       };
8941     }
8942   }
8943   jresult = new Dali::Degree((const Dali::Degree &)result);
8944   return jresult;
8945 }
8946
8947
8948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8949   void * jresult ;
8950   Dali::Radian *result = 0 ;
8951
8952   {
8953     try {
8954       result = (Dali::Radian *)new Dali::Radian();
8955     } catch (std::out_of_range& e) {
8956       {
8957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (std::exception& e) {
8960       {
8961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8962       };
8963     } catch (...) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8966       };
8967     }
8968   }
8969   jresult = (void *)result;
8970   return jresult;
8971 }
8972
8973
8974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8975   void * jresult ;
8976   float arg1 ;
8977   Dali::Radian *result = 0 ;
8978
8979   arg1 = (float)jarg1;
8980   {
8981     try {
8982       result = (Dali::Radian *)new Dali::Radian(arg1);
8983     } catch (std::out_of_range& e) {
8984       {
8985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8986       };
8987     } catch (std::exception& e) {
8988       {
8989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8990       };
8991     } catch (...) {
8992       {
8993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8994       };
8995     }
8996   }
8997   jresult = (void *)result;
8998   return jresult;
8999 }
9000
9001
9002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9003   void * jresult ;
9004   Dali::Degree arg1 ;
9005   Dali::Degree *argp1 ;
9006   Dali::Radian *result = 0 ;
9007
9008   argp1 = (Dali::Degree *)jarg1;
9009   if (!argp1) {
9010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9011     return 0;
9012   }
9013   arg1 = *argp1;
9014   {
9015     try {
9016       result = (Dali::Radian *)new Dali::Radian(arg1);
9017     } catch (std::out_of_range& e) {
9018       {
9019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9020       };
9021     } catch (std::exception& e) {
9022       {
9023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9024       };
9025     } catch (...) {
9026       {
9027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9028       };
9029     }
9030   }
9031   jresult = (void *)result;
9032   return jresult;
9033 }
9034
9035
9036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9037   void * jresult ;
9038   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9039   float arg2 ;
9040   Dali::Radian *result = 0 ;
9041
9042   arg1 = (Dali::Radian *)jarg1;
9043   arg2 = (float)jarg2;
9044   {
9045     try {
9046       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9047     } catch (std::out_of_range& e) {
9048       {
9049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9050       };
9051     } catch (std::exception& e) {
9052       {
9053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9054       };
9055     } catch (...) {
9056       {
9057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9058       };
9059     }
9060   }
9061   jresult = (void *)result;
9062   return jresult;
9063 }
9064
9065
9066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9067   void * jresult ;
9068   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9069   Dali::Degree arg2 ;
9070   Dali::Degree *argp2 ;
9071   Dali::Radian *result = 0 ;
9072
9073   arg1 = (Dali::Radian *)jarg1;
9074   argp2 = (Dali::Degree *)jarg2;
9075   if (!argp2) {
9076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9077     return 0;
9078   }
9079   arg2 = *argp2;
9080   {
9081     try {
9082       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9083     } catch (std::out_of_range& e) {
9084       {
9085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9086       };
9087     } catch (std::exception& e) {
9088       {
9089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9090       };
9091     } catch (...) {
9092       {
9093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9094       };
9095     }
9096   }
9097   jresult = (void *)result;
9098   return jresult;
9099 }
9100
9101
9102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9103   float jresult ;
9104   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9105   float result;
9106
9107   arg1 = (Dali::Radian *)jarg1;
9108   {
9109     try {
9110       result = (float)((Dali::Radian const *)arg1)->operator float();
9111     } catch (std::out_of_range& e) {
9112       {
9113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9114       };
9115     } catch (std::exception& e) {
9116       {
9117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9118       };
9119     } catch (...) {
9120       {
9121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9122       };
9123     }
9124   }
9125   jresult = result;
9126   return jresult;
9127 }
9128
9129
9130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9131   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9132   float arg2 ;
9133
9134   arg1 = (Dali::Radian *)jarg1;
9135   arg2 = (float)jarg2;
9136   if (arg1) (arg1)->radian = arg2;
9137 }
9138
9139
9140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9141   float jresult ;
9142   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9143   float result;
9144
9145   arg1 = (Dali::Radian *)jarg1;
9146   result = (float) ((arg1)->radian);
9147   jresult = result;
9148   return jresult;
9149 }
9150
9151
9152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9153   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9154
9155   arg1 = (Dali::Radian *)jarg1;
9156   {
9157     try {
9158       delete arg1;
9159     } catch (std::out_of_range& e) {
9160       {
9161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9162       };
9163     } catch (std::exception& e) {
9164       {
9165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9166       };
9167     } catch (...) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9170       };
9171     }
9172   }
9173 }
9174
9175
9176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9177   unsigned int jresult ;
9178   Dali::Radian arg1 ;
9179   Dali::Radian arg2 ;
9180   Dali::Radian *argp1 ;
9181   Dali::Radian *argp2 ;
9182   bool result;
9183
9184   argp1 = (Dali::Radian *)jarg1;
9185   if (!argp1) {
9186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9187     return 0;
9188   }
9189   arg1 = *argp1;
9190   argp2 = (Dali::Radian *)jarg2;
9191   if (!argp2) {
9192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9193     return 0;
9194   }
9195   arg2 = *argp2;
9196   {
9197     try {
9198       result = (bool)Dali::operator ==(arg1,arg2);
9199     } catch (std::out_of_range& e) {
9200       {
9201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9202       };
9203     } catch (std::exception& e) {
9204       {
9205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9206       };
9207     } catch (...) {
9208       {
9209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9210       };
9211     }
9212   }
9213   jresult = result;
9214   return jresult;
9215 }
9216
9217
9218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9219   unsigned int jresult ;
9220   Dali::Radian arg1 ;
9221   Dali::Radian arg2 ;
9222   Dali::Radian *argp1 ;
9223   Dali::Radian *argp2 ;
9224   bool result;
9225
9226   argp1 = (Dali::Radian *)jarg1;
9227   if (!argp1) {
9228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9229     return 0;
9230   }
9231   arg1 = *argp1;
9232   argp2 = (Dali::Radian *)jarg2;
9233   if (!argp2) {
9234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9235     return 0;
9236   }
9237   arg2 = *argp2;
9238   {
9239     try {
9240       result = (bool)Dali::operator !=(arg1,arg2);
9241     } catch (std::out_of_range& e) {
9242       {
9243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9244       };
9245     } catch (std::exception& e) {
9246       {
9247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9248       };
9249     } catch (...) {
9250       {
9251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9252       };
9253     }
9254   }
9255   jresult = result;
9256   return jresult;
9257 }
9258
9259
9260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9261   unsigned int jresult ;
9262   Dali::Radian arg1 ;
9263   Dali::Degree arg2 ;
9264   Dali::Radian *argp1 ;
9265   Dali::Degree *argp2 ;
9266   bool result;
9267
9268   argp1 = (Dali::Radian *)jarg1;
9269   if (!argp1) {
9270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9271     return 0;
9272   }
9273   arg1 = *argp1;
9274   argp2 = (Dali::Degree *)jarg2;
9275   if (!argp2) {
9276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9277     return 0;
9278   }
9279   arg2 = *argp2;
9280   {
9281     try {
9282       result = (bool)Dali::operator ==(arg1,arg2);
9283     } catch (std::out_of_range& e) {
9284       {
9285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9286       };
9287     } catch (std::exception& e) {
9288       {
9289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (...) {
9292       {
9293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9294       };
9295     }
9296   }
9297   jresult = result;
9298   return jresult;
9299 }
9300
9301
9302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9303   unsigned int jresult ;
9304   Dali::Radian arg1 ;
9305   Dali::Degree arg2 ;
9306   Dali::Radian *argp1 ;
9307   Dali::Degree *argp2 ;
9308   bool result;
9309
9310   argp1 = (Dali::Radian *)jarg1;
9311   if (!argp1) {
9312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9313     return 0;
9314   }
9315   arg1 = *argp1;
9316   argp2 = (Dali::Degree *)jarg2;
9317   if (!argp2) {
9318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9319     return 0;
9320   }
9321   arg2 = *argp2;
9322   {
9323     try {
9324       result = (bool)Dali::operator !=(arg1,arg2);
9325     } catch (std::out_of_range& e) {
9326       {
9327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9328       };
9329     } catch (std::exception& e) {
9330       {
9331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9332       };
9333     } catch (...) {
9334       {
9335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9336       };
9337     }
9338   }
9339   jresult = result;
9340   return jresult;
9341 }
9342
9343
9344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9345   unsigned int jresult ;
9346   Dali::Degree arg1 ;
9347   Dali::Radian arg2 ;
9348   Dali::Degree *argp1 ;
9349   Dali::Radian *argp2 ;
9350   bool result;
9351
9352   argp1 = (Dali::Degree *)jarg1;
9353   if (!argp1) {
9354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9355     return 0;
9356   }
9357   arg1 = *argp1;
9358   argp2 = (Dali::Radian *)jarg2;
9359   if (!argp2) {
9360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9361     return 0;
9362   }
9363   arg2 = *argp2;
9364   {
9365     try {
9366       result = (bool)Dali::operator ==(arg1,arg2);
9367     } catch (std::out_of_range& e) {
9368       {
9369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9370       };
9371     } catch (std::exception& e) {
9372       {
9373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (...) {
9376       {
9377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9378       };
9379     }
9380   }
9381   jresult = result;
9382   return jresult;
9383 }
9384
9385
9386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9387   unsigned int jresult ;
9388   Dali::Degree arg1 ;
9389   Dali::Radian arg2 ;
9390   Dali::Degree *argp1 ;
9391   Dali::Radian *argp2 ;
9392   bool result;
9393
9394   argp1 = (Dali::Degree *)jarg1;
9395   if (!argp1) {
9396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9397     return 0;
9398   }
9399   arg1 = *argp1;
9400   argp2 = (Dali::Radian *)jarg2;
9401   if (!argp2) {
9402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9403     return 0;
9404   }
9405   arg2 = *argp2;
9406   {
9407     try {
9408       result = (bool)Dali::operator !=(arg1,arg2);
9409     } catch (std::out_of_range& e) {
9410       {
9411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9412       };
9413     } catch (std::exception& e) {
9414       {
9415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9416       };
9417     } catch (...) {
9418       {
9419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9420       };
9421     }
9422   }
9423   jresult = result;
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9429   unsigned int jresult ;
9430   Dali::Radian arg1 ;
9431   Dali::Radian arg2 ;
9432   Dali::Radian *argp1 ;
9433   Dali::Radian *argp2 ;
9434   bool result;
9435
9436   argp1 = (Dali::Radian *)jarg1;
9437   if (!argp1) {
9438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9439     return 0;
9440   }
9441   arg1 = *argp1;
9442   argp2 = (Dali::Radian *)jarg2;
9443   if (!argp2) {
9444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9445     return 0;
9446   }
9447   arg2 = *argp2;
9448   {
9449     try {
9450       result = (bool)Dali::operator >(arg1,arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (...) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9462       };
9463     }
9464   }
9465   jresult = result;
9466   return jresult;
9467 }
9468
9469
9470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9471   unsigned int jresult ;
9472   Dali::Radian arg1 ;
9473   Dali::Degree arg2 ;
9474   Dali::Radian *argp1 ;
9475   Dali::Degree *argp2 ;
9476   bool result;
9477
9478   argp1 = (Dali::Radian *)jarg1;
9479   if (!argp1) {
9480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9481     return 0;
9482   }
9483   arg1 = *argp1;
9484   argp2 = (Dali::Degree *)jarg2;
9485   if (!argp2) {
9486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9487     return 0;
9488   }
9489   arg2 = *argp2;
9490   {
9491     try {
9492       result = (bool)Dali::operator >(arg1,arg2);
9493     } catch (std::out_of_range& e) {
9494       {
9495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9496       };
9497     } catch (std::exception& e) {
9498       {
9499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9500       };
9501     } catch (...) {
9502       {
9503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9504       };
9505     }
9506   }
9507   jresult = result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9513   unsigned int jresult ;
9514   Dali::Degree arg1 ;
9515   Dali::Radian arg2 ;
9516   Dali::Degree *argp1 ;
9517   Dali::Radian *argp2 ;
9518   bool result;
9519
9520   argp1 = (Dali::Degree *)jarg1;
9521   if (!argp1) {
9522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9523     return 0;
9524   }
9525   arg1 = *argp1;
9526   argp2 = (Dali::Radian *)jarg2;
9527   if (!argp2) {
9528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9529     return 0;
9530   }
9531   arg2 = *argp2;
9532   {
9533     try {
9534       result = (bool)Dali::operator >(arg1,arg2);
9535     } catch (std::out_of_range& e) {
9536       {
9537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9538       };
9539     } catch (std::exception& e) {
9540       {
9541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9542       };
9543     } catch (...) {
9544       {
9545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9546       };
9547     }
9548   }
9549   jresult = result;
9550   return jresult;
9551 }
9552
9553
9554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9555   unsigned int jresult ;
9556   Dali::Radian arg1 ;
9557   Dali::Radian arg2 ;
9558   Dali::Radian *argp1 ;
9559   Dali::Radian *argp2 ;
9560   bool result;
9561
9562   argp1 = (Dali::Radian *)jarg1;
9563   if (!argp1) {
9564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9565     return 0;
9566   }
9567   arg1 = *argp1;
9568   argp2 = (Dali::Radian *)jarg2;
9569   if (!argp2) {
9570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9571     return 0;
9572   }
9573   arg2 = *argp2;
9574   {
9575     try {
9576       result = (bool)Dali::operator <(arg1,arg2);
9577     } catch (std::out_of_range& e) {
9578       {
9579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9580       };
9581     } catch (std::exception& e) {
9582       {
9583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (...) {
9586       {
9587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9588       };
9589     }
9590   }
9591   jresult = result;
9592   return jresult;
9593 }
9594
9595
9596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9597   unsigned int jresult ;
9598   Dali::Radian arg1 ;
9599   Dali::Degree arg2 ;
9600   Dali::Radian *argp1 ;
9601   Dali::Degree *argp2 ;
9602   bool result;
9603
9604   argp1 = (Dali::Radian *)jarg1;
9605   if (!argp1) {
9606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9607     return 0;
9608   }
9609   arg1 = *argp1;
9610   argp2 = (Dali::Degree *)jarg2;
9611   if (!argp2) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9613     return 0;
9614   }
9615   arg2 = *argp2;
9616   {
9617     try {
9618       result = (bool)Dali::operator <(arg1,arg2);
9619     } catch (std::out_of_range& e) {
9620       {
9621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (std::exception& e) {
9624       {
9625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9626       };
9627     } catch (...) {
9628       {
9629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9630       };
9631     }
9632   }
9633   jresult = result;
9634   return jresult;
9635 }
9636
9637
9638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9639   unsigned int jresult ;
9640   Dali::Degree arg1 ;
9641   Dali::Radian arg2 ;
9642   Dali::Degree *argp1 ;
9643   Dali::Radian *argp2 ;
9644   bool result;
9645
9646   argp1 = (Dali::Degree *)jarg1;
9647   if (!argp1) {
9648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9649     return 0;
9650   }
9651   arg1 = *argp1;
9652   argp2 = (Dali::Radian *)jarg2;
9653   if (!argp2) {
9654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9655     return 0;
9656   }
9657   arg2 = *argp2;
9658   {
9659     try {
9660       result = (bool)Dali::operator <(arg1,arg2);
9661     } catch (std::out_of_range& e) {
9662       {
9663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9664       };
9665     } catch (std::exception& e) {
9666       {
9667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9668       };
9669     } catch (...) {
9670       {
9671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9672       };
9673     }
9674   }
9675   jresult = result;
9676   return jresult;
9677 }
9678
9679
9680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9681   void * jresult ;
9682   Dali::Radian arg1 ;
9683   float arg2 ;
9684   Dali::Radian *argp1 ;
9685   Dali::Radian result;
9686
9687   argp1 = (Dali::Radian *)jarg1;
9688   if (!argp1) {
9689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9690     return 0;
9691   }
9692   arg1 = *argp1;
9693   arg2 = (float)jarg2;
9694   {
9695     try {
9696       result = Dali::operator *(arg1,arg2);
9697     } catch (std::out_of_range& e) {
9698       {
9699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9700       };
9701     } catch (std::exception& e) {
9702       {
9703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9704       };
9705     } catch (...) {
9706       {
9707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9708       };
9709     }
9710   }
9711   jresult = new Dali::Radian((const Dali::Radian &)result);
9712   return jresult;
9713 }
9714
9715
9716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9717   void * jresult ;
9718   Dali::Radian arg1 ;
9719   Dali::Radian *argp1 ;
9720   Dali::Radian result;
9721
9722   argp1 = (Dali::Radian *)jarg1;
9723   if (!argp1) {
9724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9725     return 0;
9726   }
9727   arg1 = *argp1;
9728   {
9729     try {
9730       result = Dali::operator -(arg1);
9731     } catch (std::out_of_range& e) {
9732       {
9733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9734       };
9735     } catch (std::exception& e) {
9736       {
9737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9738       };
9739     } catch (...) {
9740       {
9741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9742       };
9743     }
9744   }
9745   jresult = new Dali::Radian((const Dali::Radian &)result);
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9751   void * jresult ;
9752   Dali::Radian arg1 ;
9753   float arg2 ;
9754   float arg3 ;
9755   Dali::Radian *argp1 ;
9756   Dali::Radian result;
9757
9758   argp1 = (Dali::Radian *)jarg1;
9759   if (!argp1) {
9760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9761     return 0;
9762   }
9763   arg1 = *argp1;
9764   arg2 = (float)jarg2;
9765   arg3 = (float)jarg3;
9766   {
9767     try {
9768       result = Dali::Clamp(arg1,arg2,arg3);
9769     } catch (std::out_of_range& e) {
9770       {
9771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9772       };
9773     } catch (std::exception& e) {
9774       {
9775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9776       };
9777     } catch (...) {
9778       {
9779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9780       };
9781     }
9782   }
9783   jresult = new Dali::Radian((const Dali::Radian &)result);
9784   return jresult;
9785 }
9786
9787
9788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9789   void * jresult ;
9790   Dali::Quaternion *result = 0 ;
9791
9792   {
9793     try {
9794       result = (Dali::Quaternion *)new Dali::Quaternion();
9795     } catch (std::out_of_range& e) {
9796       {
9797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9798       };
9799     } catch (std::exception& e) {
9800       {
9801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9802       };
9803     } catch (...) {
9804       {
9805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9806       };
9807     }
9808   }
9809   jresult = (void *)result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9815   void * jresult ;
9816   Dali::Radian arg1 ;
9817   Dali::Vector3 *arg2 = 0 ;
9818   Dali::Radian *argp1 ;
9819   Dali::Quaternion *result = 0 ;
9820
9821   argp1 = (Dali::Radian *)jarg1;
9822   if (!argp1) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9824     return 0;
9825   }
9826   arg1 = *argp1;
9827   arg2 = (Dali::Vector3 *)jarg2;
9828   if (!arg2) {
9829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9830     return 0;
9831   }
9832   {
9833     try {
9834       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9835     } catch (std::out_of_range& e) {
9836       {
9837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9838       };
9839     } catch (std::exception& e) {
9840       {
9841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9842       };
9843     } catch (...) {
9844       {
9845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9846       };
9847     }
9848   }
9849   jresult = (void *)result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9855   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9856
9857   arg1 = (Dali::Quaternion *)jarg1;
9858   {
9859     try {
9860       delete arg1;
9861     } catch (std::out_of_range& e) {
9862       {
9863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9864       };
9865     } catch (std::exception& e) {
9866       {
9867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9868       };
9869     } catch (...) {
9870       {
9871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9872       };
9873     }
9874   }
9875 }
9876
9877
9878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9879   void * jresult ;
9880   Dali::Quaternion *result = 0 ;
9881
9882   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9883   jresult = (void *)result;
9884   return jresult;
9885 }
9886
9887
9888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9889   unsigned int jresult ;
9890   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9891   bool result;
9892
9893   arg1 = (Dali::Quaternion *)jarg1;
9894   {
9895     try {
9896       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9897     } catch (std::out_of_range& e) {
9898       {
9899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9900       };
9901     } catch (std::exception& e) {
9902       {
9903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9904       };
9905     } catch (...) {
9906       {
9907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9908       };
9909     }
9910   }
9911   jresult = result;
9912   return jresult;
9913 }
9914
9915
9916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9917   unsigned int jresult ;
9918   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9919   Dali::Vector3 *arg2 = 0 ;
9920   Dali::Radian *arg3 = 0 ;
9921   bool result;
9922
9923   arg1 = (Dali::Quaternion *)jarg1;
9924   arg2 = (Dali::Vector3 *)jarg2;
9925   if (!arg2) {
9926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9927     return 0;
9928   }
9929   arg3 = (Dali::Radian *)jarg3;
9930   if (!arg3) {
9931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9932     return 0;
9933   }
9934   {
9935     try {
9936       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9937     } catch (std::out_of_range& e) {
9938       {
9939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9940       };
9941     } catch (std::exception& e) {
9942       {
9943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9944       };
9945     } catch (...) {
9946       {
9947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9948       };
9949     }
9950   }
9951   jresult = result;
9952   return jresult;
9953 }
9954
9955
9956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9957   void * jresult ;
9958   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9959   Dali::Quaternion *arg2 = 0 ;
9960   Dali::Quaternion result;
9961
9962   arg1 = (Dali::Quaternion *)jarg1;
9963   arg2 = (Dali::Quaternion *)jarg2;
9964   if (!arg2) {
9965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9966     return 0;
9967   }
9968   {
9969     try {
9970       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9971     } catch (std::out_of_range& e) {
9972       {
9973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9974       };
9975     } catch (std::exception& e) {
9976       {
9977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9978       };
9979     } catch (...) {
9980       {
9981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9982       };
9983     }
9984   }
9985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9986   return jresult;
9987 }
9988
9989
9990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9991   void * jresult ;
9992   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9993   Dali::Quaternion *arg2 = 0 ;
9994   Dali::Quaternion result;
9995
9996   arg1 = (Dali::Quaternion *)jarg1;
9997   arg2 = (Dali::Quaternion *)jarg2;
9998   if (!arg2) {
9999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10000     return 0;
10001   }
10002   {
10003     try {
10004       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10005     } catch (std::out_of_range& e) {
10006       {
10007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10008       };
10009     } catch (std::exception& e) {
10010       {
10011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10012       };
10013     } catch (...) {
10014       {
10015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10016       };
10017     }
10018   }
10019   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10020   return jresult;
10021 }
10022
10023
10024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10025   void * jresult ;
10026   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10027   Dali::Quaternion *arg2 = 0 ;
10028   Dali::Quaternion result;
10029
10030   arg1 = (Dali::Quaternion *)jarg1;
10031   arg2 = (Dali::Quaternion *)jarg2;
10032   if (!arg2) {
10033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10034     return 0;
10035   }
10036   {
10037     try {
10038       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10039     } catch (std::out_of_range& e) {
10040       {
10041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10042       };
10043     } catch (std::exception& e) {
10044       {
10045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10046       };
10047     } catch (...) {
10048       {
10049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10050       };
10051     }
10052   }
10053   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10054   return jresult;
10055 }
10056
10057
10058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10059   void * jresult ;
10060   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10061   Dali::Vector3 *arg2 = 0 ;
10062   Dali::Vector3 result;
10063
10064   arg1 = (Dali::Quaternion *)jarg1;
10065   arg2 = (Dali::Vector3 *)jarg2;
10066   if (!arg2) {
10067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10068     return 0;
10069   }
10070   {
10071     try {
10072       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10073     } catch (std::out_of_range& e) {
10074       {
10075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10076       };
10077     } catch (std::exception& e) {
10078       {
10079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10080       };
10081     } catch (...) {
10082       {
10083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10084       };
10085     }
10086   }
10087   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10088   return jresult;
10089 }
10090
10091
10092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10093   void * jresult ;
10094   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10095   Dali::Quaternion *arg2 = 0 ;
10096   Dali::Quaternion result;
10097
10098   arg1 = (Dali::Quaternion *)jarg1;
10099   arg2 = (Dali::Quaternion *)jarg2;
10100   if (!arg2) {
10101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10102     return 0;
10103   }
10104   {
10105     try {
10106       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10107     } catch (std::out_of_range& e) {
10108       {
10109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10110       };
10111     } catch (std::exception& e) {
10112       {
10113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10114       };
10115     } catch (...) {
10116       {
10117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10118       };
10119     }
10120   }
10121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10122   return jresult;
10123 }
10124
10125
10126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10127   void * jresult ;
10128   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10129   float arg2 ;
10130   Dali::Quaternion result;
10131
10132   arg1 = (Dali::Quaternion *)jarg1;
10133   arg2 = (float)jarg2;
10134   {
10135     try {
10136       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10137     } catch (std::out_of_range& e) {
10138       {
10139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10140       };
10141     } catch (std::exception& e) {
10142       {
10143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10144       };
10145     } catch (...) {
10146       {
10147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10148       };
10149     }
10150   }
10151   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10157   void * jresult ;
10158   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10159   float arg2 ;
10160   Dali::Quaternion result;
10161
10162   arg1 = (Dali::Quaternion *)jarg1;
10163   arg2 = (float)jarg2;
10164   {
10165     try {
10166       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10167     } catch (std::out_of_range& e) {
10168       {
10169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10170       };
10171     } catch (std::exception& e) {
10172       {
10173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10174       };
10175     } catch (...) {
10176       {
10177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10178       };
10179     }
10180   }
10181   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10182   return jresult;
10183 }
10184
10185
10186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10187   void * jresult ;
10188   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10189   Dali::Quaternion result;
10190
10191   arg1 = (Dali::Quaternion *)jarg1;
10192   {
10193     try {
10194       result = ((Dali::Quaternion const *)arg1)->operator -();
10195     } catch (std::out_of_range& e) {
10196       {
10197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10198       };
10199     } catch (std::exception& e) {
10200       {
10201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10202       };
10203     } catch (...) {
10204       {
10205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10206       };
10207     }
10208   }
10209   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10210   return jresult;
10211 }
10212
10213
10214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10215   void * jresult ;
10216   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10217   Dali::Quaternion *arg2 = 0 ;
10218   Dali::Quaternion *result = 0 ;
10219
10220   arg1 = (Dali::Quaternion *)jarg1;
10221   arg2 = (Dali::Quaternion *)jarg2;
10222   if (!arg2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10224     return 0;
10225   }
10226   {
10227     try {
10228       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (...) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10240       };
10241     }
10242   }
10243   jresult = (void *)result;
10244   return jresult;
10245 }
10246
10247
10248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10249   void * jresult ;
10250   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10251   Dali::Quaternion *arg2 = 0 ;
10252   Dali::Quaternion *result = 0 ;
10253
10254   arg1 = (Dali::Quaternion *)jarg1;
10255   arg2 = (Dali::Quaternion *)jarg2;
10256   if (!arg2) {
10257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10258     return 0;
10259   }
10260   {
10261     try {
10262       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10263     } catch (std::out_of_range& e) {
10264       {
10265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10266       };
10267     } catch (std::exception& e) {
10268       {
10269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10270       };
10271     } catch (...) {
10272       {
10273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10274       };
10275     }
10276   }
10277   jresult = (void *)result;
10278   return jresult;
10279 }
10280
10281
10282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10283   void * jresult ;
10284   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10285   Dali::Quaternion *arg2 = 0 ;
10286   Dali::Quaternion *result = 0 ;
10287
10288   arg1 = (Dali::Quaternion *)jarg1;
10289   arg2 = (Dali::Quaternion *)jarg2;
10290   if (!arg2) {
10291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10292     return 0;
10293   }
10294   {
10295     try {
10296       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10297     } catch (std::out_of_range& e) {
10298       {
10299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10300       };
10301     } catch (std::exception& e) {
10302       {
10303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10304       };
10305     } catch (...) {
10306       {
10307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10308       };
10309     }
10310   }
10311   jresult = (void *)result;
10312   return jresult;
10313 }
10314
10315
10316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10317   void * jresult ;
10318   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10319   float arg2 ;
10320   Dali::Quaternion *result = 0 ;
10321
10322   arg1 = (Dali::Quaternion *)jarg1;
10323   arg2 = (float)jarg2;
10324   {
10325     try {
10326       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10327     } catch (std::out_of_range& e) {
10328       {
10329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (std::exception& e) {
10332       {
10333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341   jresult = (void *)result;
10342   return jresult;
10343 }
10344
10345
10346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10347   void * jresult ;
10348   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10349   float arg2 ;
10350   Dali::Quaternion *result = 0 ;
10351
10352   arg1 = (Dali::Quaternion *)jarg1;
10353   arg2 = (float)jarg2;
10354   {
10355     try {
10356       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10357     } catch (std::out_of_range& e) {
10358       {
10359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (std::exception& e) {
10362       {
10363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10364       };
10365     } catch (...) {
10366       {
10367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10368       };
10369     }
10370   }
10371   jresult = (void *)result;
10372   return jresult;
10373 }
10374
10375
10376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10377   unsigned int jresult ;
10378   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10379   Dali::Quaternion *arg2 = 0 ;
10380   bool result;
10381
10382   arg1 = (Dali::Quaternion *)jarg1;
10383   arg2 = (Dali::Quaternion *)jarg2;
10384   if (!arg2) {
10385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10386     return 0;
10387   }
10388   {
10389     try {
10390       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10391     } catch (std::out_of_range& e) {
10392       {
10393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10394       };
10395     } catch (std::exception& e) {
10396       {
10397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10398       };
10399     } catch (...) {
10400       {
10401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10402       };
10403     }
10404   }
10405   jresult = result;
10406   return jresult;
10407 }
10408
10409
10410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10411   unsigned int jresult ;
10412   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10413   Dali::Quaternion *arg2 = 0 ;
10414   bool result;
10415
10416   arg1 = (Dali::Quaternion *)jarg1;
10417   arg2 = (Dali::Quaternion *)jarg2;
10418   if (!arg2) {
10419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10420     return 0;
10421   }
10422   {
10423     try {
10424       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10425     } catch (std::out_of_range& e) {
10426       {
10427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10428       };
10429     } catch (std::exception& e) {
10430       {
10431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10432       };
10433     } catch (...) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10436       };
10437     }
10438   }
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10445   float jresult ;
10446   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10447   float result;
10448
10449   arg1 = (Dali::Quaternion *)jarg1;
10450   {
10451     try {
10452       result = (float)((Dali::Quaternion const *)arg1)->Length();
10453     } catch (std::out_of_range& e) {
10454       {
10455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10456       };
10457     } catch (std::exception& e) {
10458       {
10459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10460       };
10461     } catch (...) {
10462       {
10463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10464       };
10465     }
10466   }
10467   jresult = result;
10468   return jresult;
10469 }
10470
10471
10472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10473   float jresult ;
10474   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10475   float result;
10476
10477   arg1 = (Dali::Quaternion *)jarg1;
10478   {
10479     try {
10480       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10481     } catch (std::out_of_range& e) {
10482       {
10483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10484       };
10485     } catch (std::exception& e) {
10486       {
10487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10488       };
10489     } catch (...) {
10490       {
10491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10492       };
10493     }
10494   }
10495   jresult = result;
10496   return jresult;
10497 }
10498
10499
10500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10501   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10502
10503   arg1 = (Dali::Quaternion *)jarg1;
10504   {
10505     try {
10506       (arg1)->Normalize();
10507     } catch (std::out_of_range& e) {
10508       {
10509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10510       };
10511     } catch (std::exception& e) {
10512       {
10513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10514       };
10515     } catch (...) {
10516       {
10517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10518       };
10519     }
10520   }
10521 }
10522
10523
10524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10525   void * jresult ;
10526   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10527   Dali::Quaternion result;
10528
10529   arg1 = (Dali::Quaternion *)jarg1;
10530   {
10531     try {
10532       result = ((Dali::Quaternion const *)arg1)->Normalized();
10533     } catch (std::out_of_range& e) {
10534       {
10535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10536       };
10537     } catch (std::exception& e) {
10538       {
10539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10540       };
10541     } catch (...) {
10542       {
10543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10544       };
10545     }
10546   }
10547   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10548   return jresult;
10549 }
10550
10551
10552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10553   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10554
10555   arg1 = (Dali::Quaternion *)jarg1;
10556   {
10557     try {
10558       (arg1)->Conjugate();
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10566       };
10567     } catch (...) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10570       };
10571     }
10572   }
10573 }
10574
10575
10576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10577   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10578
10579   arg1 = (Dali::Quaternion *)jarg1;
10580   {
10581     try {
10582       (arg1)->Invert();
10583     } catch (std::out_of_range& e) {
10584       {
10585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10586       };
10587     } catch (std::exception& e) {
10588       {
10589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10590       };
10591     } catch (...) {
10592       {
10593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10594       };
10595     }
10596   }
10597 }
10598
10599
10600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10601   void * jresult ;
10602   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10603   Dali::Quaternion result;
10604
10605   arg1 = (Dali::Quaternion *)jarg1;
10606   {
10607     try {
10608       result = ((Dali::Quaternion const *)arg1)->Log();
10609     } catch (std::out_of_range& e) {
10610       {
10611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (std::exception& e) {
10614       {
10615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10624   return jresult;
10625 }
10626
10627
10628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10629   void * jresult ;
10630   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10631   Dali::Quaternion result;
10632
10633   arg1 = (Dali::Quaternion *)jarg1;
10634   {
10635     try {
10636       result = ((Dali::Quaternion const *)arg1)->Exp();
10637     } catch (std::out_of_range& e) {
10638       {
10639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10640       };
10641     } catch (std::exception& e) {
10642       {
10643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10644       };
10645     } catch (...) {
10646       {
10647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10648       };
10649     }
10650   }
10651   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10652   return jresult;
10653 }
10654
10655
10656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10657   float jresult ;
10658   Dali::Quaternion *arg1 = 0 ;
10659   Dali::Quaternion *arg2 = 0 ;
10660   float result;
10661
10662   arg1 = (Dali::Quaternion *)jarg1;
10663   if (!arg1) {
10664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10665     return 0;
10666   }
10667   arg2 = (Dali::Quaternion *)jarg2;
10668   if (!arg2) {
10669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10670     return 0;
10671   }
10672   {
10673     try {
10674       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10675     } catch (std::out_of_range& e) {
10676       {
10677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10678       };
10679     } catch (std::exception& e) {
10680       {
10681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10682       };
10683     } catch (...) {
10684       {
10685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10686       };
10687     }
10688   }
10689   jresult = result;
10690   return jresult;
10691 }
10692
10693
10694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10695   void * jresult ;
10696   Dali::Quaternion *arg1 = 0 ;
10697   Dali::Quaternion *arg2 = 0 ;
10698   float arg3 ;
10699   Dali::Quaternion result;
10700
10701   arg1 = (Dali::Quaternion *)jarg1;
10702   if (!arg1) {
10703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10704     return 0;
10705   }
10706   arg2 = (Dali::Quaternion *)jarg2;
10707   if (!arg2) {
10708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10709     return 0;
10710   }
10711   arg3 = (float)jarg3;
10712   {
10713     try {
10714       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10715     } catch (std::out_of_range& e) {
10716       {
10717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10718       };
10719     } catch (std::exception& e) {
10720       {
10721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10722       };
10723     } catch (...) {
10724       {
10725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10726       };
10727     }
10728   }
10729   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10730   return jresult;
10731 }
10732
10733
10734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10735   void * jresult ;
10736   Dali::Quaternion *arg1 = 0 ;
10737   Dali::Quaternion *arg2 = 0 ;
10738   float arg3 ;
10739   Dali::Quaternion result;
10740
10741   arg1 = (Dali::Quaternion *)jarg1;
10742   if (!arg1) {
10743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10744     return 0;
10745   }
10746   arg2 = (Dali::Quaternion *)jarg2;
10747   if (!arg2) {
10748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10749     return 0;
10750   }
10751   arg3 = (float)jarg3;
10752   {
10753     try {
10754       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10755     } catch (std::out_of_range& e) {
10756       {
10757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10758       };
10759     } catch (std::exception& e) {
10760       {
10761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10762       };
10763     } catch (...) {
10764       {
10765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10766       };
10767     }
10768   }
10769   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10770   return jresult;
10771 }
10772
10773
10774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10775   void * jresult ;
10776   Dali::Quaternion *arg1 = 0 ;
10777   Dali::Quaternion *arg2 = 0 ;
10778   float arg3 ;
10779   Dali::Quaternion result;
10780
10781   arg1 = (Dali::Quaternion *)jarg1;
10782   if (!arg1) {
10783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10784     return 0;
10785   }
10786   arg2 = (Dali::Quaternion *)jarg2;
10787   if (!arg2) {
10788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10789     return 0;
10790   }
10791   arg3 = (float)jarg3;
10792   {
10793     try {
10794       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10795     } catch (std::out_of_range& e) {
10796       {
10797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10798       };
10799     } catch (std::exception& e) {
10800       {
10801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10802       };
10803     } catch (...) {
10804       {
10805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10806       };
10807     }
10808   }
10809   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10815   void * jresult ;
10816   Dali::Quaternion *arg1 = 0 ;
10817   Dali::Quaternion *arg2 = 0 ;
10818   Dali::Quaternion *arg3 = 0 ;
10819   Dali::Quaternion *arg4 = 0 ;
10820   float arg5 ;
10821   Dali::Quaternion result;
10822
10823   arg1 = (Dali::Quaternion *)jarg1;
10824   if (!arg1) {
10825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10826     return 0;
10827   }
10828   arg2 = (Dali::Quaternion *)jarg2;
10829   if (!arg2) {
10830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10831     return 0;
10832   }
10833   arg3 = (Dali::Quaternion *)jarg3;
10834   if (!arg3) {
10835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10836     return 0;
10837   }
10838   arg4 = (Dali::Quaternion *)jarg4;
10839   if (!arg4) {
10840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10841     return 0;
10842   }
10843   arg5 = (float)jarg5;
10844   {
10845     try {
10846       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10847     } catch (std::out_of_range& e) {
10848       {
10849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10850       };
10851     } catch (std::exception& e) {
10852       {
10853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10854       };
10855     } catch (...) {
10856       {
10857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10858       };
10859     }
10860   }
10861   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10862   return jresult;
10863 }
10864
10865
10866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10867   float jresult ;
10868   Dali::Quaternion *arg1 = 0 ;
10869   Dali::Quaternion *arg2 = 0 ;
10870   float result;
10871
10872   arg1 = (Dali::Quaternion *)jarg1;
10873   if (!arg1) {
10874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10875     return 0;
10876   }
10877   arg2 = (Dali::Quaternion *)jarg2;
10878   if (!arg2) {
10879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10880     return 0;
10881   }
10882   {
10883     try {
10884       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10885     } catch (std::out_of_range& e) {
10886       {
10887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10888       };
10889     } catch (std::exception& e) {
10890       {
10891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10892       };
10893     } catch (...) {
10894       {
10895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10896       };
10897     }
10898   }
10899   jresult = result;
10900   return jresult;
10901 }
10902
10903
10904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10905   void * jresult ;
10906   Dali::Matrix *result = 0 ;
10907
10908   {
10909     try {
10910       result = (Dali::Matrix *)new Dali::Matrix();
10911     } catch (std::out_of_range& e) {
10912       {
10913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10914       };
10915     } catch (std::exception& e) {
10916       {
10917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10918       };
10919     } catch (...) {
10920       {
10921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10922       };
10923     }
10924   }
10925   jresult = (void *)result;
10926   return jresult;
10927 }
10928
10929
10930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10931   void * jresult ;
10932   bool arg1 ;
10933   Dali::Matrix *result = 0 ;
10934
10935   arg1 = jarg1 ? true : false;
10936   {
10937     try {
10938       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10939     } catch (std::out_of_range& e) {
10940       {
10941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10942       };
10943     } catch (std::exception& e) {
10944       {
10945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10946       };
10947     } catch (...) {
10948       {
10949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10950       };
10951     }
10952   }
10953   jresult = (void *)result;
10954   return jresult;
10955 }
10956
10957
10958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10959   void * jresult ;
10960   float *arg1 = (float *) 0 ;
10961   Dali::Matrix *result = 0 ;
10962
10963   arg1 = jarg1;
10964   {
10965     try {
10966       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10967     } catch (std::out_of_range& e) {
10968       {
10969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10970       };
10971     } catch (std::exception& e) {
10972       {
10973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10974       };
10975     } catch (...) {
10976       {
10977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10978       };
10979     }
10980   }
10981   jresult = (void *)result;
10982
10983
10984   return jresult;
10985 }
10986
10987
10988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10989   void * jresult ;
10990   Dali::Quaternion *arg1 = 0 ;
10991   Dali::Matrix *result = 0 ;
10992
10993   arg1 = (Dali::Quaternion *)jarg1;
10994   if (!arg1) {
10995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10996     return 0;
10997   }
10998   {
10999     try {
11000       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11001     } catch (std::out_of_range& e) {
11002       {
11003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11004       };
11005     } catch (std::exception& e) {
11006       {
11007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11008       };
11009     } catch (...) {
11010       {
11011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11012       };
11013     }
11014   }
11015   jresult = (void *)result;
11016   return jresult;
11017 }
11018
11019
11020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11021   void * jresult ;
11022   Dali::Matrix *arg1 = 0 ;
11023   Dali::Matrix *result = 0 ;
11024
11025   arg1 = (Dali::Matrix *)jarg1;
11026   if (!arg1) {
11027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11028     return 0;
11029   }
11030   {
11031     try {
11032       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11033     } catch (std::out_of_range& e) {
11034       {
11035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11036       };
11037     } catch (std::exception& e) {
11038       {
11039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11040       };
11041     } catch (...) {
11042       {
11043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11044       };
11045     }
11046   }
11047   jresult = (void *)result;
11048   return jresult;
11049 }
11050
11051
11052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11053   void * jresult ;
11054   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11055   Dali::Matrix *arg2 = 0 ;
11056   Dali::Matrix *result = 0 ;
11057
11058   arg1 = (Dali::Matrix *)jarg1;
11059   arg2 = (Dali::Matrix *)jarg2;
11060   if (!arg2) {
11061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11062     return 0;
11063   }
11064   {
11065     try {
11066       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11067     } catch (std::out_of_range& e) {
11068       {
11069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (std::exception& e) {
11072       {
11073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081   jresult = (void *)result;
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11087   void * jresult ;
11088   Dali::Matrix *result = 0 ;
11089
11090   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11091   jresult = (void *)result;
11092   return jresult;
11093 }
11094
11095
11096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11097   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11098
11099   arg1 = (Dali::Matrix *)jarg1;
11100   {
11101     try {
11102       (arg1)->SetIdentity();
11103     } catch (std::out_of_range& e) {
11104       {
11105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11106       };
11107     } catch (std::exception& e) {
11108       {
11109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11110       };
11111     } catch (...) {
11112       {
11113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11114       };
11115     }
11116   }
11117 }
11118
11119
11120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11121   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11122   Dali::Vector3 *arg2 = 0 ;
11123
11124   arg1 = (Dali::Matrix *)jarg1;
11125   arg2 = (Dali::Vector3 *)jarg2;
11126   if (!arg2) {
11127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11128     return ;
11129   }
11130   {
11131     try {
11132       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11133     } catch (std::out_of_range& e) {
11134       {
11135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11136       };
11137     } catch (std::exception& e) {
11138       {
11139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11140       };
11141     } catch (...) {
11142       {
11143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11144       };
11145     }
11146   }
11147 }
11148
11149
11150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11151   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11152   Dali::Matrix *arg2 = 0 ;
11153
11154   arg1 = (Dali::Matrix *)jarg1;
11155   arg2 = (Dali::Matrix *)jarg2;
11156   if (!arg2) {
11157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11158     return ;
11159   }
11160   {
11161     try {
11162       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11163     } catch (std::out_of_range& e) {
11164       {
11165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11166       };
11167     } catch (std::exception& e) {
11168       {
11169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11170       };
11171     } catch (...) {
11172       {
11173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11174       };
11175     }
11176   }
11177 }
11178
11179
11180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11181   unsigned int jresult ;
11182   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11183   bool result;
11184
11185   arg1 = (Dali::Matrix *)jarg1;
11186   {
11187     try {
11188       result = (bool)(arg1)->Invert();
11189     } catch (std::out_of_range& e) {
11190       {
11191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11192       };
11193     } catch (std::exception& e) {
11194       {
11195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11196       };
11197     } catch (...) {
11198       {
11199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11200       };
11201     }
11202   }
11203   jresult = result;
11204   return jresult;
11205 }
11206
11207
11208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11209   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11210
11211   arg1 = (Dali::Matrix *)jarg1;
11212   {
11213     try {
11214       (arg1)->Transpose();
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11226       };
11227     }
11228   }
11229 }
11230
11231
11232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11233   void * jresult ;
11234   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11235   Dali::Vector3 result;
11236
11237   arg1 = (Dali::Matrix *)jarg1;
11238   {
11239     try {
11240       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11241     } catch (std::out_of_range& e) {
11242       {
11243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11244       };
11245     } catch (std::exception& e) {
11246       {
11247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11248       };
11249     } catch (...) {
11250       {
11251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11252       };
11253     }
11254   }
11255   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11256   return jresult;
11257 }
11258
11259
11260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11261   void * jresult ;
11262   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11263   Dali::Vector3 result;
11264
11265   arg1 = (Dali::Matrix *)jarg1;
11266   {
11267     try {
11268       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11269     } catch (std::out_of_range& e) {
11270       {
11271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11272       };
11273     } catch (std::exception& e) {
11274       {
11275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11276       };
11277     } catch (...) {
11278       {
11279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11280       };
11281     }
11282   }
11283   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11284   return jresult;
11285 }
11286
11287
11288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11289   void * jresult ;
11290   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11291   Dali::Vector3 result;
11292
11293   arg1 = (Dali::Matrix *)jarg1;
11294   {
11295     try {
11296       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11297     } catch (std::out_of_range& e) {
11298       {
11299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (std::exception& e) {
11302       {
11303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11304       };
11305     } catch (...) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11308       };
11309     }
11310   }
11311   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11317   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11318   Dali::Vector3 *arg2 = 0 ;
11319
11320   arg1 = (Dali::Matrix *)jarg1;
11321   arg2 = (Dali::Vector3 *)jarg2;
11322   if (!arg2) {
11323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11324     return ;
11325   }
11326   {
11327     try {
11328       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11329     } catch (std::out_of_range& e) {
11330       {
11331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11332       };
11333     } catch (std::exception& e) {
11334       {
11335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11336       };
11337     } catch (...) {
11338       {
11339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11340       };
11341     }
11342   }
11343 }
11344
11345
11346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11347   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11348   Dali::Vector3 *arg2 = 0 ;
11349
11350   arg1 = (Dali::Matrix *)jarg1;
11351   arg2 = (Dali::Vector3 *)jarg2;
11352   if (!arg2) {
11353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11354     return ;
11355   }
11356   {
11357     try {
11358       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11359     } catch (std::out_of_range& e) {
11360       {
11361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11362       };
11363     } catch (std::exception& e) {
11364       {
11365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11366       };
11367     } catch (...) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11370       };
11371     }
11372   }
11373 }
11374
11375
11376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11377   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11378   Dali::Vector3 *arg2 = 0 ;
11379
11380   arg1 = (Dali::Matrix *)jarg1;
11381   arg2 = (Dali::Vector3 *)jarg2;
11382   if (!arg2) {
11383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11384     return ;
11385   }
11386   {
11387     try {
11388       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11389     } catch (std::out_of_range& e) {
11390       {
11391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11392       };
11393     } catch (std::exception& e) {
11394       {
11395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11396       };
11397     } catch (...) {
11398       {
11399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11400       };
11401     }
11402   }
11403 }
11404
11405
11406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11407   void * jresult ;
11408   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11409   Dali::Vector4 *result = 0 ;
11410
11411   arg1 = (Dali::Matrix *)jarg1;
11412   {
11413     try {
11414       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11415     } catch (std::out_of_range& e) {
11416       {
11417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11418       };
11419     } catch (std::exception& e) {
11420       {
11421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11422       };
11423     } catch (...) {
11424       {
11425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11426       };
11427     }
11428   }
11429   jresult = (void *)result;
11430   return jresult;
11431 }
11432
11433
11434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11435   void * jresult ;
11436   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11437   Dali::Vector3 *result = 0 ;
11438
11439   arg1 = (Dali::Matrix *)jarg1;
11440   {
11441     try {
11442       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11443     } catch (std::out_of_range& e) {
11444       {
11445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11446       };
11447     } catch (std::exception& e) {
11448       {
11449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11454       };
11455     }
11456   }
11457   jresult = (void *)result;
11458   return jresult;
11459 }
11460
11461
11462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11463   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11464   Dali::Vector4 *arg2 = 0 ;
11465
11466   arg1 = (Dali::Matrix *)jarg1;
11467   arg2 = (Dali::Vector4 *)jarg2;
11468   if (!arg2) {
11469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11470     return ;
11471   }
11472   {
11473     try {
11474       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11475     } catch (std::out_of_range& e) {
11476       {
11477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11478       };
11479     } catch (std::exception& e) {
11480       {
11481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11482       };
11483     } catch (...) {
11484       {
11485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11486       };
11487     }
11488   }
11489 }
11490
11491
11492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11493   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11494   Dali::Vector3 *arg2 = 0 ;
11495
11496   arg1 = (Dali::Matrix *)jarg1;
11497   arg2 = (Dali::Vector3 *)jarg2;
11498   if (!arg2) {
11499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11500     return ;
11501   }
11502   {
11503     try {
11504       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11505     } catch (std::out_of_range& e) {
11506       {
11507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11508       };
11509     } catch (std::exception& e) {
11510       {
11511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11512       };
11513     } catch (...) {
11514       {
11515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11516       };
11517     }
11518   }
11519 }
11520
11521
11522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11523   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11524
11525   arg1 = (Dali::Matrix *)jarg1;
11526   {
11527     try {
11528       (arg1)->OrthoNormalize();
11529     } catch (std::out_of_range& e) {
11530       {
11531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11532       };
11533     } catch (std::exception& e) {
11534       {
11535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11536       };
11537     } catch (...) {
11538       {
11539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11540       };
11541     }
11542   }
11543 }
11544
11545
11546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11547   void * jresult ;
11548   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11549   float *result = 0 ;
11550
11551   arg1 = (Dali::Matrix *)jarg1;
11552   {
11553     try {
11554       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11562       };
11563     } catch (...) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11566       };
11567     }
11568   }
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11575   Dali::Matrix *arg1 = 0 ;
11576   Dali::Matrix *arg2 = 0 ;
11577   Dali::Matrix *arg3 = 0 ;
11578
11579   arg1 = (Dali::Matrix *)jarg1;
11580   if (!arg1) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11582     return ;
11583   }
11584   arg2 = (Dali::Matrix *)jarg2;
11585   if (!arg2) {
11586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11587     return ;
11588   }
11589   arg3 = (Dali::Matrix *)jarg3;
11590   if (!arg3) {
11591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11592     return ;
11593   }
11594   {
11595     try {
11596       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11597     } catch (std::out_of_range& e) {
11598       {
11599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11600       };
11601     } catch (std::exception& e) {
11602       {
11603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11604       };
11605     } catch (...) {
11606       {
11607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11608       };
11609     }
11610   }
11611 }
11612
11613
11614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11615   Dali::Matrix *arg1 = 0 ;
11616   Dali::Matrix *arg2 = 0 ;
11617   Dali::Quaternion *arg3 = 0 ;
11618
11619   arg1 = (Dali::Matrix *)jarg1;
11620   if (!arg1) {
11621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11622     return ;
11623   }
11624   arg2 = (Dali::Matrix *)jarg2;
11625   if (!arg2) {
11626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11627     return ;
11628   }
11629   arg3 = (Dali::Quaternion *)jarg3;
11630   if (!arg3) {
11631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11632     return ;
11633   }
11634   {
11635     try {
11636       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11637     } catch (std::out_of_range& e) {
11638       {
11639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11640       };
11641     } catch (std::exception& e) {
11642       {
11643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11644       };
11645     } catch (...) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11648       };
11649     }
11650   }
11651 }
11652
11653
11654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11655   void * jresult ;
11656   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11657   Dali::Vector4 *arg2 = 0 ;
11658   Dali::Vector4 result;
11659
11660   arg1 = (Dali::Matrix *)jarg1;
11661   arg2 = (Dali::Vector4 *)jarg2;
11662   if (!arg2) {
11663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11664     return 0;
11665   }
11666   {
11667     try {
11668       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11669     } catch (std::out_of_range& e) {
11670       {
11671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11672       };
11673     } catch (std::exception& e) {
11674       {
11675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11676       };
11677     } catch (...) {
11678       {
11679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11680       };
11681     }
11682   }
11683   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11684   return jresult;
11685 }
11686
11687
11688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11689   unsigned int jresult ;
11690   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11691   Dali::Matrix *arg2 = 0 ;
11692   bool result;
11693
11694   arg1 = (Dali::Matrix *)jarg1;
11695   arg2 = (Dali::Matrix *)jarg2;
11696   if (!arg2) {
11697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11698     return 0;
11699   }
11700   {
11701     try {
11702       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11703     } catch (std::out_of_range& e) {
11704       {
11705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11706       };
11707     } catch (std::exception& e) {
11708       {
11709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11710       };
11711     } catch (...) {
11712       {
11713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11714       };
11715     }
11716   }
11717   jresult = result;
11718   return jresult;
11719 }
11720
11721
11722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11723   unsigned int jresult ;
11724   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11725   Dali::Matrix *arg2 = 0 ;
11726   bool result;
11727
11728   arg1 = (Dali::Matrix *)jarg1;
11729   arg2 = (Dali::Matrix *)jarg2;
11730   if (!arg2) {
11731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11732     return 0;
11733   }
11734   {
11735     try {
11736       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11737     } catch (std::out_of_range& e) {
11738       {
11739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11740       };
11741     } catch (std::exception& e) {
11742       {
11743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11744       };
11745     } catch (...) {
11746       {
11747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11748       };
11749     }
11750   }
11751   jresult = result;
11752   return jresult;
11753 }
11754
11755
11756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11757   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11758   Dali::Vector3 *arg2 = 0 ;
11759   Dali::Quaternion *arg3 = 0 ;
11760   Dali::Vector3 *arg4 = 0 ;
11761
11762   arg1 = (Dali::Matrix *)jarg1;
11763   arg2 = (Dali::Vector3 *)jarg2;
11764   if (!arg2) {
11765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11766     return ;
11767   }
11768   arg3 = (Dali::Quaternion *)jarg3;
11769   if (!arg3) {
11770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11771     return ;
11772   }
11773   arg4 = (Dali::Vector3 *)jarg4;
11774   if (!arg4) {
11775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11776     return ;
11777   }
11778   {
11779     try {
11780       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11781     } catch (std::out_of_range& e) {
11782       {
11783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11784       };
11785     } catch (std::exception& e) {
11786       {
11787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (...) {
11790       {
11791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11792       };
11793     }
11794   }
11795 }
11796
11797
11798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11799   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11800   Dali::Vector3 *arg2 = 0 ;
11801   Dali::Quaternion *arg3 = 0 ;
11802   Dali::Vector3 *arg4 = 0 ;
11803
11804   arg1 = (Dali::Matrix *)jarg1;
11805   arg2 = (Dali::Vector3 *)jarg2;
11806   if (!arg2) {
11807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11808     return ;
11809   }
11810   arg3 = (Dali::Quaternion *)jarg3;
11811   if (!arg3) {
11812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11813     return ;
11814   }
11815   arg4 = (Dali::Vector3 *)jarg4;
11816   if (!arg4) {
11817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11818     return ;
11819   }
11820   {
11821     try {
11822       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11823     } catch (std::out_of_range& e) {
11824       {
11825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11826       };
11827     } catch (std::exception& e) {
11828       {
11829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11830       };
11831     } catch (...) {
11832       {
11833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11834       };
11835     }
11836   }
11837 }
11838
11839
11840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11841   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11842   Dali::Vector3 *arg2 = 0 ;
11843   Dali::Vector3 *arg3 = 0 ;
11844   Dali::Vector3 *arg4 = 0 ;
11845   Dali::Vector3 *arg5 = 0 ;
11846
11847   arg1 = (Dali::Matrix *)jarg1;
11848   arg2 = (Dali::Vector3 *)jarg2;
11849   if (!arg2) {
11850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11851     return ;
11852   }
11853   arg3 = (Dali::Vector3 *)jarg3;
11854   if (!arg3) {
11855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11856     return ;
11857   }
11858   arg4 = (Dali::Vector3 *)jarg4;
11859   if (!arg4) {
11860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11861     return ;
11862   }
11863   arg5 = (Dali::Vector3 *)jarg5;
11864   if (!arg5) {
11865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11866     return ;
11867   }
11868   {
11869     try {
11870       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11871     } catch (std::out_of_range& e) {
11872       {
11873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11874       };
11875     } catch (std::exception& e) {
11876       {
11877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11878       };
11879     } catch (...) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11882       };
11883     }
11884   }
11885 }
11886
11887
11888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11889   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11890   Dali::Vector3 *arg2 = 0 ;
11891   Dali::Quaternion *arg3 = 0 ;
11892   Dali::Vector3 *arg4 = 0 ;
11893
11894   arg1 = (Dali::Matrix *)jarg1;
11895   arg2 = (Dali::Vector3 *)jarg2;
11896   if (!arg2) {
11897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11898     return ;
11899   }
11900   arg3 = (Dali::Quaternion *)jarg3;
11901   if (!arg3) {
11902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11903     return ;
11904   }
11905   arg4 = (Dali::Vector3 *)jarg4;
11906   if (!arg4) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11908     return ;
11909   }
11910   {
11911     try {
11912       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11913     } catch (std::out_of_range& e) {
11914       {
11915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11916       };
11917     } catch (std::exception& e) {
11918       {
11919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11920       };
11921     } catch (...) {
11922       {
11923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11924       };
11925     }
11926   }
11927 }
11928
11929
11930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11931   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11932
11933   arg1 = (Dali::Matrix *)jarg1;
11934   {
11935     try {
11936       delete arg1;
11937     } catch (std::out_of_range& e) {
11938       {
11939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11940       };
11941     } catch (std::exception& e) {
11942       {
11943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11944       };
11945     } catch (...) {
11946       {
11947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11948       };
11949     }
11950   }
11951 }
11952
11953
11954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11955   void * jresult ;
11956   Dali::Matrix3 *result = 0 ;
11957
11958   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11959   jresult = (void *)result;
11960   return jresult;
11961 }
11962
11963
11964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11965   void * jresult ;
11966   Dali::Matrix3 *result = 0 ;
11967
11968   {
11969     try {
11970       result = (Dali::Matrix3 *)new Dali::Matrix3();
11971     } catch (std::out_of_range& e) {
11972       {
11973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11974       };
11975     } catch (std::exception& e) {
11976       {
11977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11978       };
11979     } catch (...) {
11980       {
11981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11982       };
11983     }
11984   }
11985   jresult = (void *)result;
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11991   void * jresult ;
11992   Dali::Matrix3 *arg1 = 0 ;
11993   Dali::Matrix3 *result = 0 ;
11994
11995   arg1 = (Dali::Matrix3 *)jarg1;
11996   if (!arg1) {
11997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11998     return 0;
11999   }
12000   {
12001     try {
12002       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12003     } catch (std::out_of_range& e) {
12004       {
12005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12006       };
12007     } catch (std::exception& e) {
12008       {
12009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12010       };
12011     } catch (...) {
12012       {
12013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12014       };
12015     }
12016   }
12017   jresult = (void *)result;
12018   return jresult;
12019 }
12020
12021
12022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12023   void * jresult ;
12024   Dali::Matrix *arg1 = 0 ;
12025   Dali::Matrix3 *result = 0 ;
12026
12027   arg1 = (Dali::Matrix *)jarg1;
12028   if (!arg1) {
12029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12030     return 0;
12031   }
12032   {
12033     try {
12034       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12035     } catch (std::out_of_range& e) {
12036       {
12037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12038       };
12039     } catch (std::exception& e) {
12040       {
12041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12042       };
12043     } catch (...) {
12044       {
12045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12046       };
12047     }
12048   }
12049   jresult = (void *)result;
12050   return jresult;
12051 }
12052
12053
12054 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) {
12055   void * jresult ;
12056   float arg1 ;
12057   float arg2 ;
12058   float arg3 ;
12059   float arg4 ;
12060   float arg5 ;
12061   float arg6 ;
12062   float arg7 ;
12063   float arg8 ;
12064   float arg9 ;
12065   Dali::Matrix3 *result = 0 ;
12066
12067   arg1 = (float)jarg1;
12068   arg2 = (float)jarg2;
12069   arg3 = (float)jarg3;
12070   arg4 = (float)jarg4;
12071   arg5 = (float)jarg5;
12072   arg6 = (float)jarg6;
12073   arg7 = (float)jarg7;
12074   arg8 = (float)jarg8;
12075   arg9 = (float)jarg9;
12076   {
12077     try {
12078       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12079     } catch (std::out_of_range& e) {
12080       {
12081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12082       };
12083     } catch (std::exception& e) {
12084       {
12085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12086       };
12087     } catch (...) {
12088       {
12089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12090       };
12091     }
12092   }
12093   jresult = (void *)result;
12094   return jresult;
12095 }
12096
12097
12098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12099   void * jresult ;
12100   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12101   Dali::Matrix3 *arg2 = 0 ;
12102   Dali::Matrix3 *result = 0 ;
12103
12104   arg1 = (Dali::Matrix3 *)jarg1;
12105   arg2 = (Dali::Matrix3 *)jarg2;
12106   if (!arg2) {
12107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12108     return 0;
12109   }
12110   {
12111     try {
12112       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127   jresult = (void *)result;
12128   return jresult;
12129 }
12130
12131
12132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12133   void * jresult ;
12134   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12135   Dali::Matrix *arg2 = 0 ;
12136   Dali::Matrix3 *result = 0 ;
12137
12138   arg1 = (Dali::Matrix3 *)jarg1;
12139   arg2 = (Dali::Matrix *)jarg2;
12140   if (!arg2) {
12141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12142     return 0;
12143   }
12144   {
12145     try {
12146       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12147     } catch (std::out_of_range& e) {
12148       {
12149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12150       };
12151     } catch (std::exception& e) {
12152       {
12153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12154       };
12155     } catch (...) {
12156       {
12157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12158       };
12159     }
12160   }
12161   jresult = (void *)result;
12162   return jresult;
12163 }
12164
12165
12166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12167   unsigned int jresult ;
12168   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12169   Dali::Matrix3 *arg2 = 0 ;
12170   bool result;
12171
12172   arg1 = (Dali::Matrix3 *)jarg1;
12173   arg2 = (Dali::Matrix3 *)jarg2;
12174   if (!arg2) {
12175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12176     return 0;
12177   }
12178   {
12179     try {
12180       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12181     } catch (std::out_of_range& e) {
12182       {
12183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12184       };
12185     } catch (std::exception& e) {
12186       {
12187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12188       };
12189     } catch (...) {
12190       {
12191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12192       };
12193     }
12194   }
12195   jresult = result;
12196   return jresult;
12197 }
12198
12199
12200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12201   unsigned int jresult ;
12202   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12203   Dali::Matrix3 *arg2 = 0 ;
12204   bool result;
12205
12206   arg1 = (Dali::Matrix3 *)jarg1;
12207   arg2 = (Dali::Matrix3 *)jarg2;
12208   if (!arg2) {
12209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12210     return 0;
12211   }
12212   {
12213     try {
12214       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12215     } catch (std::out_of_range& e) {
12216       {
12217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12218       };
12219     } catch (std::exception& e) {
12220       {
12221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (...) {
12224       {
12225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12226       };
12227     }
12228   }
12229   jresult = result;
12230   return jresult;
12231 }
12232
12233
12234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12235   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12236
12237   arg1 = (Dali::Matrix3 *)jarg1;
12238   {
12239     try {
12240       delete arg1;
12241     } catch (std::out_of_range& e) {
12242       {
12243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12244       };
12245     } catch (std::exception& e) {
12246       {
12247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12248       };
12249     } catch (...) {
12250       {
12251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12252       };
12253     }
12254   }
12255 }
12256
12257
12258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12259   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12260
12261   arg1 = (Dali::Matrix3 *)jarg1;
12262   {
12263     try {
12264       (arg1)->SetIdentity();
12265     } catch (std::out_of_range& e) {
12266       {
12267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12268       };
12269     } catch (std::exception& e) {
12270       {
12271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12272       };
12273     } catch (...) {
12274       {
12275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12276       };
12277     }
12278   }
12279 }
12280
12281
12282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12283   void * jresult ;
12284   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12285   float *result = 0 ;
12286
12287   arg1 = (Dali::Matrix3 *)jarg1;
12288   {
12289     try {
12290       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12291     } catch (std::out_of_range& e) {
12292       {
12293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (std::exception& e) {
12296       {
12297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12298       };
12299     } catch (...) {
12300       {
12301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12302       };
12303     }
12304   }
12305   jresult = (void *)result;
12306   return jresult;
12307 }
12308
12309
12310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12311   unsigned int jresult ;
12312   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12313   bool result;
12314
12315   arg1 = (Dali::Matrix3 *)jarg1;
12316   {
12317     try {
12318       result = (bool)(arg1)->Invert();
12319     } catch (std::out_of_range& e) {
12320       {
12321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (std::exception& e) {
12324       {
12325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (...) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12330       };
12331     }
12332   }
12333   jresult = result;
12334   return jresult;
12335 }
12336
12337
12338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12339   unsigned int jresult ;
12340   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12341   bool result;
12342
12343   arg1 = (Dali::Matrix3 *)jarg1;
12344   {
12345     try {
12346       result = (bool)(arg1)->Transpose();
12347     } catch (std::out_of_range& e) {
12348       {
12349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12350       };
12351     } catch (std::exception& e) {
12352       {
12353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12354       };
12355     } catch (...) {
12356       {
12357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12358       };
12359     }
12360   }
12361   jresult = result;
12362   return jresult;
12363 }
12364
12365
12366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12367   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12368   float arg2 ;
12369
12370   arg1 = (Dali::Matrix3 *)jarg1;
12371   arg2 = (float)jarg2;
12372   {
12373     try {
12374       (arg1)->Scale(arg2);
12375     } catch (std::out_of_range& e) {
12376       {
12377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12378       };
12379     } catch (std::exception& e) {
12380       {
12381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12382       };
12383     } catch (...) {
12384       {
12385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12386       };
12387     }
12388   }
12389 }
12390
12391
12392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12393   float jresult ;
12394   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12395   float result;
12396
12397   arg1 = (Dali::Matrix3 *)jarg1;
12398   {
12399     try {
12400       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12401     } catch (std::out_of_range& e) {
12402       {
12403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12404       };
12405     } catch (std::exception& e) {
12406       {
12407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12408       };
12409     } catch (...) {
12410       {
12411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12412       };
12413     }
12414   }
12415   jresult = result;
12416   return jresult;
12417 }
12418
12419
12420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12421   unsigned int jresult ;
12422   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12423   bool result;
12424
12425   arg1 = (Dali::Matrix3 *)jarg1;
12426   {
12427     try {
12428       result = (bool)(arg1)->ScaledInverseTranspose();
12429     } catch (std::out_of_range& e) {
12430       {
12431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12432       };
12433     } catch (std::exception& e) {
12434       {
12435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12436       };
12437     } catch (...) {
12438       {
12439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12440       };
12441     }
12442   }
12443   jresult = result;
12444   return jresult;
12445 }
12446
12447
12448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12449   Dali::Matrix3 *arg1 = 0 ;
12450   Dali::Matrix3 *arg2 = 0 ;
12451   Dali::Matrix3 *arg3 = 0 ;
12452
12453   arg1 = (Dali::Matrix3 *)jarg1;
12454   if (!arg1) {
12455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12456     return ;
12457   }
12458   arg2 = (Dali::Matrix3 *)jarg2;
12459   if (!arg2) {
12460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12461     return ;
12462   }
12463   arg3 = (Dali::Matrix3 *)jarg3;
12464   if (!arg3) {
12465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12466     return ;
12467   }
12468   {
12469     try {
12470       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12471     } catch (std::out_of_range& e) {
12472       {
12473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12474       };
12475     } catch (std::exception& e) {
12476       {
12477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12478       };
12479     } catch (...) {
12480       {
12481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12482       };
12483     }
12484   }
12485 }
12486
12487
12488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12489   float jresult ;
12490   float arg1 ;
12491   float arg2 ;
12492   float result;
12493
12494   arg1 = (float)jarg1;
12495   arg2 = (float)jarg2;
12496   {
12497     try {
12498       result = (float)Dali::Random::Range(arg1,arg2);
12499     } catch (std::out_of_range& e) {
12500       {
12501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12502       };
12503     } catch (std::exception& e) {
12504       {
12505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12506       };
12507     } catch (...) {
12508       {
12509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12510       };
12511     }
12512   }
12513   jresult = result;
12514   return jresult;
12515 }
12516
12517
12518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12519   void * jresult ;
12520   Dali::Vector4 result;
12521
12522   {
12523     try {
12524       result = Dali::Random::Axis();
12525     } catch (std::out_of_range& e) {
12526       {
12527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12528       };
12529     } catch (std::exception& e) {
12530       {
12531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (...) {
12534       {
12535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12536       };
12537     }
12538   }
12539   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12540   return jresult;
12541 }
12542
12543
12544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12545   void * jresult ;
12546   Dali::AngleAxis *result = 0 ;
12547
12548   {
12549     try {
12550       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12551     } catch (std::out_of_range& e) {
12552       {
12553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12554       };
12555     } catch (std::exception& e) {
12556       {
12557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12558       };
12559     } catch (...) {
12560       {
12561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12562       };
12563     }
12564   }
12565   jresult = (void *)result;
12566   return jresult;
12567 }
12568
12569
12570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12571   void * jresult ;
12572   Dali::Radian arg1 ;
12573   Dali::Vector3 *arg2 = 0 ;
12574   Dali::Radian *argp1 ;
12575   Dali::AngleAxis *result = 0 ;
12576
12577   argp1 = (Dali::Radian *)jarg1;
12578   if (!argp1) {
12579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12580     return 0;
12581   }
12582   arg1 = *argp1;
12583   arg2 = (Dali::Vector3 *)jarg2;
12584   if (!arg2) {
12585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12586     return 0;
12587   }
12588   {
12589     try {
12590       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12591     } catch (std::out_of_range& e) {
12592       {
12593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12594       };
12595     } catch (std::exception& e) {
12596       {
12597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (...) {
12600       {
12601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12602       };
12603     }
12604   }
12605   jresult = (void *)result;
12606   return jresult;
12607 }
12608
12609
12610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12611   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12612   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12613
12614   arg1 = (Dali::AngleAxis *)jarg1;
12615   arg2 = (Dali::Radian *)jarg2;
12616   if (arg1) (arg1)->angle = *arg2;
12617 }
12618
12619
12620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12621   void * jresult ;
12622   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12623   Dali::Radian *result = 0 ;
12624
12625   arg1 = (Dali::AngleAxis *)jarg1;
12626   result = (Dali::Radian *)& ((arg1)->angle);
12627   jresult = (void *)result;
12628   return jresult;
12629 }
12630
12631
12632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12633   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12634   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12635
12636   arg1 = (Dali::AngleAxis *)jarg1;
12637   arg2 = (Dali::Vector3 *)jarg2;
12638   if (arg1) (arg1)->axis = *arg2;
12639 }
12640
12641
12642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12643   void * jresult ;
12644   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12645   Dali::Vector3 *result = 0 ;
12646
12647   arg1 = (Dali::AngleAxis *)jarg1;
12648   result = (Dali::Vector3 *)& ((arg1)->axis);
12649   jresult = (void *)result;
12650   return jresult;
12651 }
12652
12653
12654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12655   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12656
12657   arg1 = (Dali::AngleAxis *)jarg1;
12658   {
12659     try {
12660       delete arg1;
12661     } catch (std::out_of_range& e) {
12662       {
12663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12664       };
12665     } catch (std::exception& e) {
12666       {
12667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (...) {
12670       {
12671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12672       };
12673     }
12674   }
12675 }
12676
12677
12678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12679   unsigned int jresult ;
12680   Dali::AngleAxis *arg1 = 0 ;
12681   Dali::AngleAxis *arg2 = 0 ;
12682   bool result;
12683
12684   arg1 = (Dali::AngleAxis *)jarg1;
12685   if (!arg1) {
12686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12687     return 0;
12688   }
12689   arg2 = (Dali::AngleAxis *)jarg2;
12690   if (!arg2) {
12691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12692     return 0;
12693   }
12694   {
12695     try {
12696       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12697     } catch (std::out_of_range& e) {
12698       {
12699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12700       };
12701     } catch (std::exception& e) {
12702       {
12703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12704       };
12705     } catch (...) {
12706       {
12707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12708       };
12709     }
12710   }
12711   jresult = result;
12712   return jresult;
12713 }
12714
12715
12716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12717   unsigned int jresult ;
12718   unsigned int arg1 ;
12719   unsigned int result;
12720
12721   arg1 = (unsigned int)jarg1;
12722   {
12723     try {
12724       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12725     } catch (std::out_of_range& e) {
12726       {
12727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12728       };
12729     } catch (std::exception& e) {
12730       {
12731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12732       };
12733     } catch (...) {
12734       {
12735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12736       };
12737     }
12738   }
12739   jresult = result;
12740   return jresult;
12741 }
12742
12743
12744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12745   unsigned int jresult ;
12746   unsigned int arg1 ;
12747   bool result;
12748
12749   arg1 = (unsigned int)jarg1;
12750   {
12751     try {
12752       result = (bool)Dali::IsPowerOfTwo(arg1);
12753     } catch (std::out_of_range& e) {
12754       {
12755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12756       };
12757     } catch (std::exception& e) {
12758       {
12759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12760       };
12761     } catch (...) {
12762       {
12763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12764       };
12765     }
12766   }
12767   jresult = result;
12768   return jresult;
12769 }
12770
12771
12772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12773   float jresult ;
12774   float arg1 ;
12775   float arg2 ;
12776   float result;
12777
12778   arg1 = (float)jarg1;
12779   arg2 = (float)jarg2;
12780   {
12781     try {
12782       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12783     } catch (std::out_of_range& e) {
12784       {
12785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12786       };
12787     } catch (std::exception& e) {
12788       {
12789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12790       };
12791     } catch (...) {
12792       {
12793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12794       };
12795     }
12796   }
12797   jresult = result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12803   unsigned int jresult ;
12804   float arg1 ;
12805   bool result;
12806
12807   arg1 = (float)jarg1;
12808   {
12809     try {
12810       result = (bool)Dali::EqualsZero(arg1);
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (...) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12822       };
12823     }
12824   }
12825   jresult = result;
12826   return jresult;
12827 }
12828
12829
12830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12831   unsigned int jresult ;
12832   float arg1 ;
12833   float arg2 ;
12834   bool result;
12835
12836   arg1 = (float)jarg1;
12837   arg2 = (float)jarg2;
12838   {
12839     try {
12840       result = (bool)Dali::Equals(arg1,arg2);
12841     } catch (std::out_of_range& e) {
12842       {
12843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12844       };
12845     } catch (std::exception& e) {
12846       {
12847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12848       };
12849     } catch (...) {
12850       {
12851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12852       };
12853     }
12854   }
12855   jresult = result;
12856   return jresult;
12857 }
12858
12859
12860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12861   unsigned int jresult ;
12862   float arg1 ;
12863   float arg2 ;
12864   float arg3 ;
12865   bool result;
12866
12867   arg1 = (float)jarg1;
12868   arg2 = (float)jarg2;
12869   arg3 = (float)jarg3;
12870   {
12871     try {
12872       result = (bool)Dali::Equals(arg1,arg2,arg3);
12873     } catch (std::out_of_range& e) {
12874       {
12875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12876       };
12877     } catch (std::exception& e) {
12878       {
12879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12880       };
12881     } catch (...) {
12882       {
12883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12884       };
12885     }
12886   }
12887   jresult = result;
12888   return jresult;
12889 }
12890
12891
12892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12893   float jresult ;
12894   float arg1 ;
12895   int arg2 ;
12896   float result;
12897
12898   arg1 = (float)jarg1;
12899   arg2 = (int)jarg2;
12900   {
12901     try {
12902       result = (float)Dali::Round(arg1,arg2);
12903     } catch (std::out_of_range& e) {
12904       {
12905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12906       };
12907     } catch (std::exception& e) {
12908       {
12909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12910       };
12911     } catch (...) {
12912       {
12913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12914       };
12915     }
12916   }
12917   jresult = result;
12918   return jresult;
12919 }
12920
12921
12922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12923   float jresult ;
12924   float arg1 ;
12925   float arg2 ;
12926   float arg3 ;
12927   float result;
12928
12929   arg1 = (float)jarg1;
12930   arg2 = (float)jarg2;
12931   arg3 = (float)jarg3;
12932   {
12933     try {
12934       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12935     } catch (std::out_of_range& e) {
12936       {
12937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12938       };
12939     } catch (std::exception& e) {
12940       {
12941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12942       };
12943     } catch (...) {
12944       {
12945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12946       };
12947     }
12948   }
12949   jresult = result;
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12955   float jresult ;
12956   float arg1 ;
12957   float arg2 ;
12958   float arg3 ;
12959   float arg4 ;
12960   float result;
12961
12962   arg1 = (float)jarg1;
12963   arg2 = (float)jarg2;
12964   arg3 = (float)jarg3;
12965   arg4 = (float)jarg4;
12966   {
12967     try {
12968       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12969     } catch (std::out_of_range& e) {
12970       {
12971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12972       };
12973     } catch (std::exception& e) {
12974       {
12975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12976       };
12977     } catch (...) {
12978       {
12979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12980       };
12981     }
12982   }
12983   jresult = result;
12984   return jresult;
12985 }
12986
12987
12988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12989   int jresult ;
12990   int result;
12991
12992   result = (int)(int)Dali::Property::INVALID_INDEX;
12993   jresult = result;
12994   return jresult;
12995 }
12996
12997
12998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12999   int jresult ;
13000   int result;
13001
13002   result = (int)(int)Dali::Property::INVALID_KEY;
13003   jresult = result;
13004   return jresult;
13005 }
13006
13007
13008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13009   int jresult ;
13010   int result;
13011
13012   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13013   jresult = result;
13014   return jresult;
13015 }
13016
13017
13018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13019   void * jresult ;
13020   Dali::Handle *arg1 = 0 ;
13021   Dali::Property::Index arg2 ;
13022   Dali::Property *result = 0 ;
13023
13024   arg1 = (Dali::Handle *)jarg1;
13025   if (!arg1) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13027     return 0;
13028   }
13029   arg2 = (Dali::Property::Index)jarg2;
13030   {
13031     try {
13032       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13033     } catch (std::out_of_range& e) {
13034       {
13035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13036       };
13037     } catch (std::exception& e) {
13038       {
13039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13040       };
13041     } catch (...) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13044       };
13045     }
13046   }
13047   jresult = (void *)result;
13048   return jresult;
13049 }
13050
13051
13052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13053   void * jresult ;
13054   Dali::Handle *arg1 = 0 ;
13055   Dali::Property::Index arg2 ;
13056   int arg3 ;
13057   Dali::Property *result = 0 ;
13058
13059   arg1 = (Dali::Handle *)jarg1;
13060   if (!arg1) {
13061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13062     return 0;
13063   }
13064   arg2 = (Dali::Property::Index)jarg2;
13065   arg3 = (int)jarg3;
13066   {
13067     try {
13068       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (...) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13080       };
13081     }
13082   }
13083   jresult = (void *)result;
13084   return jresult;
13085 }
13086
13087
13088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13089   void * jresult ;
13090   Dali::Handle *arg1 = 0 ;
13091   std::string *arg2 = 0 ;
13092   Dali::Property *result = 0 ;
13093
13094   arg1 = (Dali::Handle *)jarg1;
13095   if (!arg1) {
13096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13097     return 0;
13098   }
13099   if (!jarg2) {
13100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13101     return 0;
13102   }
13103   std::string arg2_str(jarg2);
13104   arg2 = &arg2_str;
13105   {
13106     try {
13107       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13108     } catch (std::out_of_range& e) {
13109       {
13110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13111       };
13112     } catch (std::exception& e) {
13113       {
13114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13115       };
13116     } catch (...) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13119       };
13120     }
13121   }
13122   jresult = (void *)result;
13123
13124   //argout typemap for const std::string&
13125
13126   return jresult;
13127 }
13128
13129
13130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13131   void * jresult ;
13132   Dali::Handle *arg1 = 0 ;
13133   std::string *arg2 = 0 ;
13134   int arg3 ;
13135   Dali::Property *result = 0 ;
13136
13137   arg1 = (Dali::Handle *)jarg1;
13138   if (!arg1) {
13139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13140     return 0;
13141   }
13142   if (!jarg2) {
13143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13144     return 0;
13145   }
13146   std::string arg2_str(jarg2);
13147   arg2 = &arg2_str;
13148   arg3 = (int)jarg3;
13149   {
13150     try {
13151       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13152     } catch (std::out_of_range& e) {
13153       {
13154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13155       };
13156     } catch (std::exception& e) {
13157       {
13158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13163       };
13164     }
13165   }
13166   jresult = (void *)result;
13167
13168   //argout typemap for const std::string&
13169
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13175   Dali::Property *arg1 = (Dali::Property *) 0 ;
13176
13177   arg1 = (Dali::Property *)jarg1;
13178   {
13179     try {
13180       delete arg1;
13181     } catch (std::out_of_range& e) {
13182       {
13183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13184       };
13185     } catch (std::exception& e) {
13186       {
13187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13188       };
13189     } catch (...) {
13190       {
13191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13192       };
13193     }
13194   }
13195 }
13196
13197
13198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13199   Dali::Property *arg1 = (Dali::Property *) 0 ;
13200   Dali::Handle *arg2 = 0 ;
13201
13202   arg1 = (Dali::Property *)jarg1;
13203   arg2 = (Dali::Handle *)jarg2;
13204   if (!arg2) {
13205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13206     return ;
13207   }
13208   if (arg1) (arg1)->object = *arg2;
13209 }
13210
13211
13212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13213   void * jresult ;
13214   Dali::Property *arg1 = (Dali::Property *) 0 ;
13215   Dali::Handle *result = 0 ;
13216
13217   arg1 = (Dali::Property *)jarg1;
13218   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13219   jresult = (void *)result;
13220   return jresult;
13221 }
13222
13223
13224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13225   Dali::Property *arg1 = (Dali::Property *) 0 ;
13226   Dali::Property::Index arg2 ;
13227
13228   arg1 = (Dali::Property *)jarg1;
13229   arg2 = (Dali::Property::Index)jarg2;
13230   if (arg1) (arg1)->propertyIndex = arg2;
13231 }
13232
13233
13234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13235   int jresult ;
13236   Dali::Property *arg1 = (Dali::Property *) 0 ;
13237   Dali::Property::Index result;
13238
13239   arg1 = (Dali::Property *)jarg1;
13240   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13241   jresult = result;
13242   return jresult;
13243 }
13244
13245
13246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13247   Dali::Property *arg1 = (Dali::Property *) 0 ;
13248   int arg2 ;
13249
13250   arg1 = (Dali::Property *)jarg1;
13251   arg2 = (int)jarg2;
13252   if (arg1) (arg1)->componentIndex = arg2;
13253 }
13254
13255
13256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13257   int jresult ;
13258   Dali::Property *arg1 = (Dali::Property *) 0 ;
13259   int result;
13260
13261   arg1 = (Dali::Property *)jarg1;
13262   result = (int) ((arg1)->componentIndex);
13263   jresult = result;
13264   return jresult;
13265 }
13266
13267
13268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13269   void * jresult ;
13270   Dali::Property::Array *result = 0 ;
13271
13272   {
13273     try {
13274       result = (Dali::Property::Array *)new Dali::Property::Array();
13275     } catch (std::out_of_range& e) {
13276       {
13277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13278       };
13279     } catch (std::exception& e) {
13280       {
13281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13282       };
13283     } catch (...) {
13284       {
13285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13286       };
13287     }
13288   }
13289   jresult = (void *)result;
13290   return jresult;
13291 }
13292
13293
13294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13295   void * jresult ;
13296   Dali::Property::Array *arg1 = 0 ;
13297   Dali::Property::Array *result = 0 ;
13298
13299   arg1 = (Dali::Property::Array *)jarg1;
13300   if (!arg1) {
13301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13302     return 0;
13303   }
13304   {
13305     try {
13306       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13307     } catch (std::out_of_range& e) {
13308       {
13309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13310       };
13311     } catch (std::exception& e) {
13312       {
13313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13314       };
13315     } catch (...) {
13316       {
13317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13318       };
13319     }
13320   }
13321   jresult = (void *)result;
13322   return jresult;
13323 }
13324
13325
13326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13328
13329   arg1 = (Dali::Property::Array *)jarg1;
13330   {
13331     try {
13332       delete arg1;
13333     } catch (std::out_of_range& e) {
13334       {
13335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13336       };
13337     } catch (std::exception& e) {
13338       {
13339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13340       };
13341     } catch (...) {
13342       {
13343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13344       };
13345     }
13346   }
13347 }
13348
13349
13350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13351   unsigned long jresult ;
13352   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13353   Dali::Property::Array::SizeType result;
13354
13355   arg1 = (Dali::Property::Array *)jarg1;
13356   {
13357     try {
13358       result = ((Dali::Property::Array const *)arg1)->Size();
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13366       };
13367     } catch (...) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13370       };
13371     }
13372   }
13373   jresult = (unsigned long)result;
13374   return jresult;
13375 }
13376
13377
13378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13379   unsigned long jresult ;
13380   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13381   Dali::Property::Array::SizeType result;
13382
13383   arg1 = (Dali::Property::Array *)jarg1;
13384   {
13385     try {
13386       result = ((Dali::Property::Array const *)arg1)->Count();
13387     } catch (std::out_of_range& e) {
13388       {
13389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13390       };
13391     } catch (std::exception& e) {
13392       {
13393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13394       };
13395     } catch (...) {
13396       {
13397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13398       };
13399     }
13400   }
13401   jresult = (unsigned long)result;
13402   return jresult;
13403 }
13404
13405
13406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13407   unsigned int jresult ;
13408   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13409   bool result;
13410
13411   arg1 = (Dali::Property::Array *)jarg1;
13412   {
13413     try {
13414       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13415     } catch (std::out_of_range& e) {
13416       {
13417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13418       };
13419     } catch (std::exception& e) {
13420       {
13421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13422       };
13423     } catch (...) {
13424       {
13425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13426       };
13427     }
13428   }
13429   jresult = result;
13430   return jresult;
13431 }
13432
13433
13434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13435   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13436
13437   arg1 = (Dali::Property::Array *)jarg1;
13438   {
13439     try {
13440       (arg1)->Clear();
13441     } catch (std::out_of_range& e) {
13442       {
13443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13444       };
13445     } catch (std::exception& e) {
13446       {
13447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13448       };
13449     } catch (...) {
13450       {
13451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13452       };
13453     }
13454   }
13455 }
13456
13457
13458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13459   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13460   Dali::Property::Array::SizeType arg2 ;
13461
13462   arg1 = (Dali::Property::Array *)jarg1;
13463   arg2 = (Dali::Property::Array::SizeType)jarg2;
13464   {
13465     try {
13466       (arg1)->Reserve(arg2);
13467     } catch (std::out_of_range& e) {
13468       {
13469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13470       };
13471     } catch (std::exception& e) {
13472       {
13473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13474       };
13475     } catch (...) {
13476       {
13477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13478       };
13479     }
13480   }
13481 }
13482
13483
13484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13485   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13486   Dali::Property::Array::SizeType arg2 ;
13487
13488   arg1 = (Dali::Property::Array *)jarg1;
13489   arg2 = (Dali::Property::Array::SizeType)jarg2;
13490   {
13491     try {
13492       (arg1)->Resize(arg2);
13493     } catch (std::out_of_range& e) {
13494       {
13495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13496       };
13497     } catch (std::exception& e) {
13498       {
13499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13500       };
13501     } catch (...) {
13502       {
13503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13504       };
13505     }
13506   }
13507 }
13508
13509
13510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13511   unsigned long jresult ;
13512   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13513   Dali::Property::Array::SizeType result;
13514
13515   arg1 = (Dali::Property::Array *)jarg1;
13516   {
13517     try {
13518       result = (arg1)->Capacity();
13519     } catch (std::out_of_range& e) {
13520       {
13521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13522       };
13523     } catch (std::exception& e) {
13524       {
13525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13526       };
13527     } catch (...) {
13528       {
13529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13530       };
13531     }
13532   }
13533   jresult = (unsigned long)result;
13534   return jresult;
13535 }
13536
13537
13538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13539   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13540   Dali::Property::Value *arg2 = 0 ;
13541
13542   arg1 = (Dali::Property::Array *)jarg1;
13543   arg2 = (Dali::Property::Value *)jarg2;
13544   if (!arg2) {
13545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13546     return ;
13547   }
13548   {
13549     try {
13550       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13551     } catch (std::out_of_range& e) {
13552       {
13553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13554       };
13555     } catch (std::exception& e) {
13556       {
13557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13558       };
13559     } catch (...) {
13560       {
13561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13562       };
13563     }
13564   }
13565 }
13566
13567
13568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13569   void * jresult ;
13570   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13571   Dali::Property::Value *arg2 = 0 ;
13572   Dali::Property::Array *result = 0 ;
13573
13574   arg1 = (Dali::Property::Array *)jarg1;
13575   arg2 = (Dali::Property::Value *)jarg2;
13576   if (!arg2) {
13577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13578     return 0;
13579   }
13580   {
13581     try {
13582       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13583     } catch (std::out_of_range& e) {
13584       {
13585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13586       };
13587     } catch (std::exception& e) {
13588       {
13589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13590       };
13591     } catch (...) {
13592       {
13593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13594       };
13595     }
13596   }
13597   jresult = (void *)result;
13598   return jresult;
13599 }
13600
13601
13602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13603   void * jresult ;
13604   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13605   Dali::Property::Array::SizeType arg2 ;
13606   Dali::Property::Value *result = 0 ;
13607
13608   arg1 = (Dali::Property::Array *)jarg1;
13609   arg2 = (Dali::Property::Array::SizeType)jarg2;
13610   {
13611     try {
13612       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13620       };
13621     } catch (...) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13624       };
13625     }
13626   }
13627   jresult = (void *)result;
13628   return jresult;
13629 }
13630
13631
13632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13633   void * jresult ;
13634   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13635   Dali::Property::Array::SizeType arg2 ;
13636   Dali::Property::Value *result = 0 ;
13637
13638   arg1 = (Dali::Property::Array *)jarg1;
13639   arg2 = (Dali::Property::Array::SizeType)jarg2;
13640   {
13641     try {
13642       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13643     } catch (std::out_of_range& e) {
13644       {
13645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13646       };
13647     } catch (std::exception& e) {
13648       {
13649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13650       };
13651     } catch (...) {
13652       {
13653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13654       };
13655     }
13656   }
13657   jresult = (void *)result;
13658   return jresult;
13659 }
13660
13661
13662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13663   void * jresult ;
13664   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13665   Dali::Property::Array *arg2 = 0 ;
13666   Dali::Property::Array *result = 0 ;
13667
13668   arg1 = (Dali::Property::Array *)jarg1;
13669   arg2 = (Dali::Property::Array *)jarg2;
13670   if (!arg2) {
13671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13672     return 0;
13673   }
13674   {
13675     try {
13676       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13684       };
13685     } catch (...) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13688       };
13689     }
13690   }
13691   jresult = (void *)result;
13692   return jresult;
13693 }
13694
13695
13696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13697   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13698   enum Dali::Property::Key::Type arg2 ;
13699
13700   arg1 = (Dali::Property::Key *)jarg1;
13701   arg2 = (enum Dali::Property::Key::Type)jarg2;
13702   if (arg1) (arg1)->type = arg2;
13703 }
13704
13705
13706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13707   int jresult ;
13708   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13709   enum Dali::Property::Key::Type result;
13710
13711   arg1 = (Dali::Property::Key *)jarg1;
13712   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13713   jresult = (int)result;
13714   return jresult;
13715 }
13716
13717
13718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13719   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13720   Dali::Property::Index arg2 ;
13721
13722   arg1 = (Dali::Property::Key *)jarg1;
13723   arg2 = (Dali::Property::Index)jarg2;
13724   if (arg1) (arg1)->indexKey = arg2;
13725 }
13726
13727
13728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13729   int jresult ;
13730   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13731   Dali::Property::Index result;
13732
13733   arg1 = (Dali::Property::Key *)jarg1;
13734   result = (Dali::Property::Index) ((arg1)->indexKey);
13735   jresult = result;
13736   return jresult;
13737 }
13738
13739
13740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13742   std::string *arg2 = 0 ;
13743
13744   arg1 = (Dali::Property::Key *)jarg1;
13745   if (!jarg2) {
13746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13747     return ;
13748   }
13749   std::string arg2_str(jarg2);
13750   arg2 = &arg2_str;
13751   if (arg1) (arg1)->stringKey = *arg2;
13752
13753   //argout typemap for const std::string&
13754
13755 }
13756
13757
13758 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13759   char * jresult ;
13760   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13761   std::string *result = 0 ;
13762
13763   arg1 = (Dali::Property::Key *)jarg1;
13764   result = (std::string *) & ((arg1)->stringKey);
13765   jresult = SWIG_csharp_string_callback(result->c_str());
13766   return jresult;
13767 }
13768
13769
13770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13771   void * jresult ;
13772   std::string *arg1 = 0 ;
13773   Dali::Property::Key *result = 0 ;
13774
13775   if (!jarg1) {
13776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13777     return 0;
13778   }
13779   std::string arg1_str(jarg1);
13780   arg1 = &arg1_str;
13781   {
13782     try {
13783       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (...) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13795       };
13796     }
13797   }
13798   jresult = (void *)result;
13799
13800   //argout typemap for const std::string&
13801
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13807   void * jresult ;
13808   Dali::Property::Index arg1 ;
13809   Dali::Property::Key *result = 0 ;
13810
13811   arg1 = (Dali::Property::Index)jarg1;
13812   {
13813     try {
13814       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (...) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13826       };
13827     }
13828   }
13829   jresult = (void *)result;
13830   return jresult;
13831 }
13832
13833
13834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13835   unsigned int jresult ;
13836   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13837   std::string *arg2 = 0 ;
13838   bool result;
13839
13840   arg1 = (Dali::Property::Key *)jarg1;
13841   if (!jarg2) {
13842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13843     return 0;
13844   }
13845   std::string arg2_str(jarg2);
13846   arg2 = &arg2_str;
13847   {
13848     try {
13849       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (...) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13861       };
13862     }
13863   }
13864   jresult = result;
13865
13866   //argout typemap for const std::string&
13867
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13873   unsigned int jresult ;
13874   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13875   Dali::Property::Index arg2 ;
13876   bool result;
13877
13878   arg1 = (Dali::Property::Key *)jarg1;
13879   arg2 = (Dali::Property::Index)jarg2;
13880   {
13881     try {
13882       result = (bool)(arg1)->operator ==(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13890       };
13891     } catch (...) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13894       };
13895     }
13896   }
13897   jresult = result;
13898   return jresult;
13899 }
13900
13901
13902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13903   unsigned int jresult ;
13904   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13905   Dali::Property::Key *arg2 = 0 ;
13906   bool result;
13907
13908   arg1 = (Dali::Property::Key *)jarg1;
13909   arg2 = (Dali::Property::Key *)jarg2;
13910   if (!arg2) {
13911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13912     return 0;
13913   }
13914   {
13915     try {
13916       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13917     } catch (std::out_of_range& e) {
13918       {
13919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13920       };
13921     } catch (std::exception& e) {
13922       {
13923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13924       };
13925     } catch (...) {
13926       {
13927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13928       };
13929     }
13930   }
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13937   unsigned int jresult ;
13938   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13939   std::string *arg2 = 0 ;
13940   bool result;
13941
13942   arg1 = (Dali::Property::Key *)jarg1;
13943   if (!jarg2) {
13944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13945     return 0;
13946   }
13947   std::string arg2_str(jarg2);
13948   arg2 = &arg2_str;
13949   {
13950     try {
13951       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13952     } catch (std::out_of_range& e) {
13953       {
13954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13955       };
13956     } catch (std::exception& e) {
13957       {
13958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13959       };
13960     } catch (...) {
13961       {
13962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13963       };
13964     }
13965   }
13966   jresult = result;
13967
13968   //argout typemap for const std::string&
13969
13970   return jresult;
13971 }
13972
13973
13974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13975   unsigned int jresult ;
13976   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13977   Dali::Property::Index arg2 ;
13978   bool result;
13979
13980   arg1 = (Dali::Property::Key *)jarg1;
13981   arg2 = (Dali::Property::Index)jarg2;
13982   {
13983     try {
13984       result = (bool)(arg1)->operator !=(arg2);
13985     } catch (std::out_of_range& e) {
13986       {
13987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13988       };
13989     } catch (std::exception& e) {
13990       {
13991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13992       };
13993     } catch (...) {
13994       {
13995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13996       };
13997     }
13998   }
13999   jresult = result;
14000   return jresult;
14001 }
14002
14003
14004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14005   unsigned int jresult ;
14006   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14007   Dali::Property::Key *arg2 = 0 ;
14008   bool result;
14009
14010   arg1 = (Dali::Property::Key *)jarg1;
14011   arg2 = (Dali::Property::Key *)jarg2;
14012   if (!arg2) {
14013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14014     return 0;
14015   }
14016   {
14017     try {
14018       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14019     } catch (std::out_of_range& e) {
14020       {
14021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14022       };
14023     } catch (std::exception& e) {
14024       {
14025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (...) {
14028       {
14029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14030       };
14031     }
14032   }
14033   jresult = result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14039   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14040
14041   arg1 = (Dali::Property::Key *)jarg1;
14042   {
14043     try {
14044       delete arg1;
14045     } catch (std::out_of_range& e) {
14046       {
14047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14048       };
14049     } catch (std::exception& e) {
14050       {
14051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14052       };
14053     } catch (...) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14056       };
14057     }
14058   }
14059 }
14060
14061
14062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14063   void * jresult ;
14064   Dali::Property::Map *result = 0 ;
14065
14066   {
14067     try {
14068       result = (Dali::Property::Map *)new Dali::Property::Map();
14069     } catch (std::out_of_range& e) {
14070       {
14071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14072       };
14073     } catch (std::exception& e) {
14074       {
14075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14076       };
14077     } catch (...) {
14078       {
14079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14080       };
14081     }
14082   }
14083   jresult = (void *)result;
14084   return jresult;
14085 }
14086
14087
14088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14089   void * jresult ;
14090   Dali::Property::Map *arg1 = 0 ;
14091   Dali::Property::Map *result = 0 ;
14092
14093   arg1 = (Dali::Property::Map *)jarg1;
14094   if (!arg1) {
14095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14096     return 0;
14097   }
14098   {
14099     try {
14100       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14101     } catch (std::out_of_range& e) {
14102       {
14103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14104       };
14105     } catch (std::exception& e) {
14106       {
14107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14108       };
14109     } catch (...) {
14110       {
14111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14112       };
14113     }
14114   }
14115   jresult = (void *)result;
14116   return jresult;
14117 }
14118
14119
14120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14121   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14122
14123   arg1 = (Dali::Property::Map *)jarg1;
14124   {
14125     try {
14126       delete arg1;
14127     } catch (std::out_of_range& e) {
14128       {
14129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14130       };
14131     } catch (std::exception& e) {
14132       {
14133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14134       };
14135     } catch (...) {
14136       {
14137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14138       };
14139     }
14140   }
14141 }
14142
14143
14144 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14145   unsigned long jresult ;
14146   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14147   Dali::Property::Map::SizeType result;
14148
14149   arg1 = (Dali::Property::Map *)jarg1;
14150   {
14151     try {
14152       result = ((Dali::Property::Map const *)arg1)->Count();
14153     } catch (std::out_of_range& e) {
14154       {
14155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14156       };
14157     } catch (std::exception& e) {
14158       {
14159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14160       };
14161     } catch (...) {
14162       {
14163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14164       };
14165     }
14166   }
14167   jresult = (unsigned long)result;
14168   return jresult;
14169 }
14170
14171
14172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14173   unsigned int jresult ;
14174   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14175   bool result;
14176
14177   arg1 = (Dali::Property::Map *)jarg1;
14178   {
14179     try {
14180       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14181     } catch (std::out_of_range& e) {
14182       {
14183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14184       };
14185     } catch (std::exception& e) {
14186       {
14187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14188       };
14189     } catch (...) {
14190       {
14191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14192       };
14193     }
14194   }
14195   jresult = result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14202   char *arg2 = (char *) 0 ;
14203   Dali::Property::Value *arg3 = 0 ;
14204
14205   arg1 = (Dali::Property::Map *)jarg1;
14206   arg2 = (char *)jarg2;
14207   arg3 = (Dali::Property::Value *)jarg3;
14208   if (!arg3) {
14209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14210     return ;
14211   }
14212   {
14213     try {
14214       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14215     } catch (std::out_of_range& e) {
14216       {
14217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14218       };
14219     } catch (std::exception& e) {
14220       {
14221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14222       };
14223     } catch (...) {
14224       {
14225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14226       };
14227     }
14228   }
14229 }
14230
14231
14232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14233   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14234   Dali::Property::Index arg2 ;
14235   Dali::Property::Value *arg3 = 0 ;
14236
14237   arg1 = (Dali::Property::Map *)jarg1;
14238   arg2 = (Dali::Property::Index)jarg2;
14239   arg3 = (Dali::Property::Value *)jarg3;
14240   if (!arg3) {
14241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14242     return ;
14243   }
14244   {
14245     try {
14246       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14254       };
14255     } catch (...) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14258       };
14259     }
14260   }
14261 }
14262
14263
14264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14265   void * jresult ;
14266   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14267   char *arg2 = (char *) 0 ;
14268   Dali::Property::Value *arg3 = 0 ;
14269   Dali::Property::Map *result = 0 ;
14270
14271   arg1 = (Dali::Property::Map *)jarg1;
14272   arg2 = (char *)jarg2;
14273   arg3 = (Dali::Property::Value *)jarg3;
14274   if (!arg3) {
14275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14276     return 0;
14277   }
14278   {
14279     try {
14280       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14281     } catch (std::out_of_range& e) {
14282       {
14283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (std::exception& e) {
14286       {
14287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14288       };
14289     } catch (...) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14292       };
14293     }
14294   }
14295   jresult = (void *)result;
14296   return jresult;
14297 }
14298
14299
14300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14301   void * jresult ;
14302   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14303   Dali::Property::Index arg2 ;
14304   Dali::Property::Value *arg3 = 0 ;
14305   Dali::Property::Map *result = 0 ;
14306
14307   arg1 = (Dali::Property::Map *)jarg1;
14308   arg2 = (Dali::Property::Index)jarg2;
14309   arg3 = (Dali::Property::Value *)jarg3;
14310   if (!arg3) {
14311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14312     return 0;
14313   }
14314   {
14315     try {
14316       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14317     } catch (std::out_of_range& e) {
14318       {
14319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (std::exception& e) {
14322       {
14323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331   jresult = (void *)result;
14332   return jresult;
14333 }
14334
14335
14336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14337   void * jresult ;
14338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14339   Dali::Property::Map::SizeType arg2 ;
14340   Dali::Property::Value *result = 0 ;
14341
14342   arg1 = (Dali::Property::Map *)jarg1;
14343   arg2 = (Dali::Property::Map::SizeType)jarg2;
14344   {
14345     try {
14346       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14347     } catch (std::out_of_range& e) {
14348       {
14349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14350       };
14351     } catch (std::exception& e) {
14352       {
14353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (...) {
14356       {
14357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14358       };
14359     }
14360   }
14361   jresult = (void *)result;
14362   return jresult;
14363 }
14364
14365
14366 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14367   char * jresult ;
14368   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14369   Dali::Property::Map::SizeType arg2 ;
14370   std::string *result = 0 ;
14371
14372   arg1 = (Dali::Property::Map *)jarg1;
14373   arg2 = (Dali::Property::Map::SizeType)jarg2;
14374   {
14375     try {
14376       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14377     } catch (std::out_of_range& e) {
14378       {
14379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14380       };
14381     } catch (std::exception& e) {
14382       {
14383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14384       };
14385     } catch (...) {
14386       {
14387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14388       };
14389     }
14390   }
14391   jresult = SWIG_csharp_string_callback(result->c_str());
14392   return jresult;
14393 }
14394
14395
14396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14397   void * jresult ;
14398   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14399   Dali::Property::Map::SizeType arg2 ;
14400   SwigValueWrapper< Dali::Property::Key > result;
14401
14402   arg1 = (Dali::Property::Map *)jarg1;
14403   arg2 = (Dali::Property::Map::SizeType)jarg2;
14404   {
14405     try {
14406       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14407     } catch (std::out_of_range& e) {
14408       {
14409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14410       };
14411     } catch (std::exception& e) {
14412       {
14413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14414       };
14415     } catch (...) {
14416       {
14417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14418       };
14419     }
14420   }
14421   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14422   return jresult;
14423 }
14424
14425
14426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14427   void * jresult ;
14428   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14429   Dali::Property::Map::SizeType arg2 ;
14430   StringValuePair *result = 0 ;
14431
14432   arg1 = (Dali::Property::Map *)jarg1;
14433   arg2 = (Dali::Property::Map::SizeType)jarg2;
14434   {
14435     try {
14436       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14437     } catch (std::out_of_range& e) {
14438       {
14439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14440       };
14441     } catch (std::exception& e) {
14442       {
14443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14444       };
14445     } catch (...) {
14446       {
14447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14448       };
14449     }
14450   }
14451   jresult = (void *)result;
14452   return jresult;
14453 }
14454
14455
14456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14457   void * jresult ;
14458   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14459   char *arg2 = (char *) 0 ;
14460   Dali::Property::Value *result = 0 ;
14461
14462   arg1 = (Dali::Property::Map *)jarg1;
14463   arg2 = (char *)jarg2;
14464   {
14465     try {
14466       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14467     } catch (std::out_of_range& e) {
14468       {
14469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14470       };
14471     } catch (std::exception& e) {
14472       {
14473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14474       };
14475     } catch (...) {
14476       {
14477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14478       };
14479     }
14480   }
14481   jresult = (void *)result;
14482   return jresult;
14483 }
14484
14485
14486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14487   void * jresult ;
14488   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14489   Dali::Property::Index arg2 ;
14490   Dali::Property::Value *result = 0 ;
14491
14492   arg1 = (Dali::Property::Map *)jarg1;
14493   arg2 = (Dali::Property::Index)jarg2;
14494   {
14495     try {
14496       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14497     } catch (std::out_of_range& e) {
14498       {
14499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14500       };
14501     } catch (std::exception& e) {
14502       {
14503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14504       };
14505     } catch (...) {
14506       {
14507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14508       };
14509     }
14510   }
14511   jresult = (void *)result;
14512   return jresult;
14513 }
14514
14515
14516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14517   void * jresult ;
14518   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14519   Dali::Property::Index arg2 ;
14520   std::string *arg3 = 0 ;
14521   Dali::Property::Value *result = 0 ;
14522
14523   arg1 = (Dali::Property::Map *)jarg1;
14524   arg2 = (Dali::Property::Index)jarg2;
14525   if (!jarg3) {
14526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14527     return 0;
14528   }
14529   std::string arg3_str(jarg3);
14530   arg3 = &arg3_str;
14531   {
14532     try {
14533       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14534     } catch (std::out_of_range& e) {
14535       {
14536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14537       };
14538     } catch (std::exception& e) {
14539       {
14540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14541       };
14542     } catch (...) {
14543       {
14544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14545       };
14546     }
14547   }
14548   jresult = (void *)result;
14549
14550   //argout typemap for const std::string&
14551
14552   return jresult;
14553 }
14554
14555
14556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14557   void * jresult ;
14558   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14559   std::string *arg2 = 0 ;
14560   Dali::Property::Type arg3 ;
14561   Dali::Property::Value *result = 0 ;
14562
14563   arg1 = (Dali::Property::Map *)jarg1;
14564   if (!jarg2) {
14565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14566     return 0;
14567   }
14568   std::string arg2_str(jarg2);
14569   arg2 = &arg2_str;
14570   arg3 = (Dali::Property::Type)jarg3;
14571   {
14572     try {
14573       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14574     } catch (std::out_of_range& e) {
14575       {
14576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14577       };
14578     } catch (std::exception& e) {
14579       {
14580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14581       };
14582     } catch (...) {
14583       {
14584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14585       };
14586     }
14587   }
14588   jresult = (void *)result;
14589
14590   //argout typemap for const std::string&
14591
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14597   void * jresult ;
14598   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14599   Dali::Property::Index arg2 ;
14600   Dali::Property::Type arg3 ;
14601   Dali::Property::Value *result = 0 ;
14602
14603   arg1 = (Dali::Property::Map *)jarg1;
14604   arg2 = (Dali::Property::Index)jarg2;
14605   arg3 = (Dali::Property::Type)jarg3;
14606   {
14607     try {
14608       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14609     } catch (std::out_of_range& e) {
14610       {
14611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14612       };
14613     } catch (std::exception& e) {
14614       {
14615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14616       };
14617     } catch (...) {
14618       {
14619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14620       };
14621     }
14622   }
14623   jresult = (void *)result;
14624   return jresult;
14625 }
14626
14627
14628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14629   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14630
14631   arg1 = (Dali::Property::Map *)jarg1;
14632   {
14633     try {
14634       (arg1)->Clear();
14635     } catch (std::out_of_range& e) {
14636       {
14637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14638       };
14639     } catch (std::exception& e) {
14640       {
14641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14642       };
14643     } catch (...) {
14644       {
14645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14646       };
14647     }
14648   }
14649 }
14650
14651
14652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14653   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14654   Dali::Property::Map *arg2 = 0 ;
14655
14656   arg1 = (Dali::Property::Map *)jarg1;
14657   arg2 = (Dali::Property::Map *)jarg2;
14658   if (!arg2) {
14659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14660     return ;
14661   }
14662   {
14663     try {
14664       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14665     } catch (std::out_of_range& e) {
14666       {
14667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14668       };
14669     } catch (std::exception& e) {
14670       {
14671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14676       };
14677     }
14678   }
14679 }
14680
14681
14682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14683   void * jresult ;
14684   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14685   std::string *arg2 = 0 ;
14686   Dali::Property::Value *result = 0 ;
14687
14688   arg1 = (Dali::Property::Map *)jarg1;
14689   if (!jarg2) {
14690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14691     return 0;
14692   }
14693   std::string arg2_str(jarg2);
14694   arg2 = &arg2_str;
14695   {
14696     try {
14697       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14698     } catch (std::out_of_range& e) {
14699       {
14700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14701       };
14702     } catch (std::exception& e) {
14703       {
14704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14705       };
14706     } catch (...) {
14707       {
14708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14709       };
14710     }
14711   }
14712   jresult = (void *)result;
14713
14714   //argout typemap for const std::string&
14715
14716   return jresult;
14717 }
14718
14719
14720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14721   void * jresult ;
14722   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14723   Dali::Property::Index arg2 ;
14724   Dali::Property::Value *result = 0 ;
14725
14726   arg1 = (Dali::Property::Map *)jarg1;
14727   arg2 = (Dali::Property::Index)jarg2;
14728   {
14729     try {
14730       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14731     } catch (std::out_of_range& e) {
14732       {
14733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14734       };
14735     } catch (std::exception& e) {
14736       {
14737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14738       };
14739     } catch (...) {
14740       {
14741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14742       };
14743     }
14744   }
14745   jresult = (void *)result;
14746   return jresult;
14747 }
14748
14749
14750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14751   void * jresult ;
14752   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14753   Dali::Property::Map *arg2 = 0 ;
14754   Dali::Property::Map *result = 0 ;
14755
14756   arg1 = (Dali::Property::Map *)jarg1;
14757   arg2 = (Dali::Property::Map *)jarg2;
14758   if (!arg2) {
14759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14760     return 0;
14761   }
14762   {
14763     try {
14764       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14765     } catch (std::out_of_range& e) {
14766       {
14767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (std::exception& e) {
14770       {
14771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (...) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14776       };
14777     }
14778   }
14779   jresult = (void *)result;
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14785   void * jresult ;
14786   Dali::Property::Value *result = 0 ;
14787
14788   {
14789     try {
14790       result = (Dali::Property::Value *)new Dali::Property::Value();
14791     } catch (std::out_of_range& e) {
14792       {
14793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14794       };
14795     } catch (std::exception& e) {
14796       {
14797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14798       };
14799     } catch (...) {
14800       {
14801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14802       };
14803     }
14804   }
14805   jresult = (void *)result;
14806   return jresult;
14807 }
14808
14809
14810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14811   void * jresult ;
14812   bool arg1 ;
14813   Dali::Property::Value *result = 0 ;
14814
14815   arg1 = jarg1 ? true : false;
14816   {
14817     try {
14818       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14819     } catch (std::out_of_range& e) {
14820       {
14821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14822       };
14823     } catch (std::exception& e) {
14824       {
14825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14826       };
14827     } catch (...) {
14828       {
14829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14830       };
14831     }
14832   }
14833   jresult = (void *)result;
14834   return jresult;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14839   void * jresult ;
14840   int arg1 ;
14841   Dali::Property::Value *result = 0 ;
14842
14843   arg1 = (int)jarg1;
14844   {
14845     try {
14846       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14847     } catch (std::out_of_range& e) {
14848       {
14849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14850       };
14851     } catch (std::exception& e) {
14852       {
14853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14854       };
14855     } catch (...) {
14856       {
14857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14858       };
14859     }
14860   }
14861   jresult = (void *)result;
14862   return jresult;
14863 }
14864
14865
14866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14867   void * jresult ;
14868   float arg1 ;
14869   Dali::Property::Value *result = 0 ;
14870
14871   arg1 = (float)jarg1;
14872   {
14873     try {
14874       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14875     } catch (std::out_of_range& e) {
14876       {
14877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14878       };
14879     } catch (std::exception& e) {
14880       {
14881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14882       };
14883     } catch (...) {
14884       {
14885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14886       };
14887     }
14888   }
14889   jresult = (void *)result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14895   void * jresult ;
14896   Dali::Vector2 *arg1 = 0 ;
14897   Dali::Property::Value *result = 0 ;
14898
14899   arg1 = (Dali::Vector2 *)jarg1;
14900   if (!arg1) {
14901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14902     return 0;
14903   }
14904   {
14905     try {
14906       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14907     } catch (std::out_of_range& e) {
14908       {
14909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (std::exception& e) {
14912       {
14913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921   jresult = (void *)result;
14922   return jresult;
14923 }
14924
14925
14926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14927   void * jresult ;
14928   Dali::Vector3 *arg1 = 0 ;
14929   Dali::Property::Value *result = 0 ;
14930
14931   arg1 = (Dali::Vector3 *)jarg1;
14932   if (!arg1) {
14933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14934     return 0;
14935   }
14936   {
14937     try {
14938       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14939     } catch (std::out_of_range& e) {
14940       {
14941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14942       };
14943     } catch (std::exception& e) {
14944       {
14945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14946       };
14947     } catch (...) {
14948       {
14949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14950       };
14951     }
14952   }
14953   jresult = (void *)result;
14954   return jresult;
14955 }
14956
14957
14958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14959   void * jresult ;
14960   Dali::Vector4 *arg1 = 0 ;
14961   Dali::Property::Value *result = 0 ;
14962
14963   arg1 = (Dali::Vector4 *)jarg1;
14964   if (!arg1) {
14965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14966     return 0;
14967   }
14968   {
14969     try {
14970       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14978       };
14979     } catch (...) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14982       };
14983     }
14984   }
14985   jresult = (void *)result;
14986   return jresult;
14987 }
14988
14989
14990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14991   void * jresult ;
14992   Dali::Matrix3 *arg1 = 0 ;
14993   Dali::Property::Value *result = 0 ;
14994
14995   arg1 = (Dali::Matrix3 *)jarg1;
14996   if (!arg1) {
14997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14998     return 0;
14999   }
15000   {
15001     try {
15002       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15003     } catch (std::out_of_range& e) {
15004       {
15005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (std::exception& e) {
15008       {
15009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15010       };
15011     } catch (...) {
15012       {
15013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15014       };
15015     }
15016   }
15017   jresult = (void *)result;
15018   return jresult;
15019 }
15020
15021
15022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15023   void * jresult ;
15024   Dali::Matrix *arg1 = 0 ;
15025   Dali::Property::Value *result = 0 ;
15026
15027   arg1 = (Dali::Matrix *)jarg1;
15028   if (!arg1) {
15029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15030     return 0;
15031   }
15032   {
15033     try {
15034       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (...) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15046       };
15047     }
15048   }
15049   jresult = (void *)result;
15050   return jresult;
15051 }
15052
15053
15054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15055   void * jresult ;
15056   Dali::Rect< int > *arg1 = 0 ;
15057   Dali::Property::Value *result = 0 ;
15058
15059   arg1 = (Dali::Rect< int > *)jarg1;
15060   if (!arg1) {
15061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15062     return 0;
15063   }
15064   {
15065     try {
15066       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15067     } catch (std::out_of_range& e) {
15068       {
15069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15070       };
15071     } catch (std::exception& e) {
15072       {
15073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15074       };
15075     } catch (...) {
15076       {
15077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15078       };
15079     }
15080   }
15081   jresult = (void *)result;
15082   return jresult;
15083 }
15084
15085
15086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15087   void * jresult ;
15088   Dali::AngleAxis *arg1 = 0 ;
15089   Dali::Property::Value *result = 0 ;
15090
15091   arg1 = (Dali::AngleAxis *)jarg1;
15092   if (!arg1) {
15093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15094     return 0;
15095   }
15096   {
15097     try {
15098       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15106       };
15107     } catch (...) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15110       };
15111     }
15112   }
15113   jresult = (void *)result;
15114   return jresult;
15115 }
15116
15117
15118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15119   void * jresult ;
15120   Dali::Quaternion *arg1 = 0 ;
15121   Dali::Property::Value *result = 0 ;
15122
15123   arg1 = (Dali::Quaternion *)jarg1;
15124   if (!arg1) {
15125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15126     return 0;
15127   }
15128   {
15129     try {
15130       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15131     } catch (std::out_of_range& e) {
15132       {
15133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15134       };
15135     } catch (std::exception& e) {
15136       {
15137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15142       };
15143     }
15144   }
15145   jresult = (void *)result;
15146   return jresult;
15147 }
15148
15149
15150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15151   void * jresult ;
15152   std::string *arg1 = 0 ;
15153   Dali::Property::Value *result = 0 ;
15154
15155   if (!jarg1) {
15156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15157     return 0;
15158   }
15159   std::string arg1_str(jarg1);
15160   arg1 = &arg1_str;
15161   {
15162     try {
15163       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15164     } catch (std::out_of_range& e) {
15165       {
15166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15167       };
15168     } catch (std::exception& e) {
15169       {
15170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15171       };
15172     } catch (...) {
15173       {
15174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15175       };
15176     }
15177   }
15178   jresult = (void *)result;
15179
15180   //argout typemap for const std::string&
15181
15182   return jresult;
15183 }
15184
15185
15186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15187   void * jresult ;
15188   Dali::Property::Array *arg1 = 0 ;
15189   Dali::Property::Value *result = 0 ;
15190
15191   arg1 = (Dali::Property::Array *)jarg1;
15192   if (!arg1) {
15193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15194     return 0;
15195   }
15196   {
15197     try {
15198       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15199     } catch (std::out_of_range& e) {
15200       {
15201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15202       };
15203     } catch (std::exception& e) {
15204       {
15205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15206       };
15207     } catch (...) {
15208       {
15209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15210       };
15211     }
15212   }
15213   jresult = (void *)result;
15214   return jresult;
15215 }
15216
15217
15218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15219   void * jresult ;
15220   Dali::Property::Map *arg1 = 0 ;
15221   Dali::Property::Value *result = 0 ;
15222
15223   arg1 = (Dali::Property::Map *)jarg1;
15224   if (!arg1) {
15225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15226     return 0;
15227   }
15228   {
15229     try {
15230       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15231     } catch (std::out_of_range& e) {
15232       {
15233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15234       };
15235     } catch (std::exception& e) {
15236       {
15237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15242       };
15243     }
15244   }
15245   jresult = (void *)result;
15246   return jresult;
15247 }
15248
15249
15250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15251   void * jresult ;
15252   Dali::Property::Type arg1 ;
15253   Dali::Property::Value *result = 0 ;
15254
15255   arg1 = (Dali::Property::Type)jarg1;
15256   {
15257     try {
15258       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15259     } catch (std::out_of_range& e) {
15260       {
15261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15262       };
15263     } catch (std::exception& e) {
15264       {
15265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (...) {
15268       {
15269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15270       };
15271     }
15272   }
15273   jresult = (void *)result;
15274   return jresult;
15275 }
15276
15277
15278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15279   void * jresult ;
15280   Dali::Property::Value *arg1 = 0 ;
15281   Dali::Property::Value *result = 0 ;
15282
15283   arg1 = (Dali::Property::Value *)jarg1;
15284   if (!arg1) {
15285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15286     return 0;
15287   }
15288   {
15289     try {
15290       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15291     } catch (std::out_of_range& e) {
15292       {
15293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15294       };
15295     } catch (std::exception& e) {
15296       {
15297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (...) {
15300       {
15301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15302       };
15303     }
15304   }
15305   jresult = (void *)result;
15306   return jresult;
15307 }
15308
15309
15310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15311   void * jresult ;
15312   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15313   Dali::Property::Value *arg2 = 0 ;
15314   Dali::Property::Value *result = 0 ;
15315
15316   arg1 = (Dali::Property::Value *)jarg1;
15317   arg2 = (Dali::Property::Value *)jarg2;
15318   if (!arg2) {
15319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15320     return 0;
15321   }
15322   {
15323     try {
15324       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15325     } catch (std::out_of_range& e) {
15326       {
15327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15328       };
15329     } catch (std::exception& e) {
15330       {
15331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15332       };
15333     } catch (...) {
15334       {
15335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15336       };
15337     }
15338   }
15339   jresult = (void *)result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15345   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15346
15347   arg1 = (Dali::Property::Value *)jarg1;
15348   {
15349     try {
15350       delete arg1;
15351     } catch (std::out_of_range& e) {
15352       {
15353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15354       };
15355     } catch (std::exception& e) {
15356       {
15357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15358       };
15359     } catch (...) {
15360       {
15361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15362       };
15363     }
15364   }
15365 }
15366
15367
15368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15369   int jresult ;
15370   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15371   Dali::Property::Type result;
15372
15373   arg1 = (Dali::Property::Value *)jarg1;
15374   {
15375     try {
15376       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15377     } catch (std::out_of_range& e) {
15378       {
15379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15380       };
15381     } catch (std::exception& e) {
15382       {
15383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15384       };
15385     } catch (...) {
15386       {
15387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15388       };
15389     }
15390   }
15391   jresult = (int)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15397   unsigned int jresult ;
15398   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15399   bool *arg2 = 0 ;
15400   bool result;
15401
15402   arg1 = (Dali::Property::Value *)jarg1;
15403   arg2 = (bool *)jarg2;
15404   {
15405     try {
15406       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15407     } catch (std::out_of_range& e) {
15408       {
15409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15410       };
15411     } catch (std::exception& e) {
15412       {
15413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15414       };
15415     } catch (...) {
15416       {
15417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15418       };
15419     }
15420   }
15421   jresult = result;
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15427   unsigned int jresult ;
15428   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15429   float *arg2 = 0 ;
15430   bool result;
15431
15432   arg1 = (Dali::Property::Value *)jarg1;
15433   arg2 = (float *)jarg2;
15434   {
15435     try {
15436       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15437     } catch (std::out_of_range& e) {
15438       {
15439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15440       };
15441     } catch (std::exception& e) {
15442       {
15443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15444       };
15445     } catch (...) {
15446       {
15447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15448       };
15449     }
15450   }
15451   jresult = result;
15452   return jresult;
15453 }
15454
15455
15456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15457   unsigned int jresult ;
15458   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15459   int *arg2 = 0 ;
15460   bool result;
15461
15462   arg1 = (Dali::Property::Value *)jarg1;
15463   arg2 = (int *)jarg2;
15464   {
15465     try {
15466       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15467     } catch (std::out_of_range& e) {
15468       {
15469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15470       };
15471     } catch (std::exception& e) {
15472       {
15473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15474       };
15475     } catch (...) {
15476       {
15477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15478       };
15479     }
15480   }
15481   jresult = result;
15482   return jresult;
15483 }
15484
15485
15486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15487   unsigned int jresult ;
15488   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15489   Dali::Rect< int > *arg2 = 0 ;
15490   bool result;
15491
15492   arg1 = (Dali::Property::Value *)jarg1;
15493   arg2 = (Dali::Rect< int > *)jarg2;
15494   if (!arg2) {
15495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15496     return 0;
15497   }
15498   {
15499     try {
15500       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15501     } catch (std::out_of_range& e) {
15502       {
15503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15504       };
15505     } catch (std::exception& e) {
15506       {
15507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15508       };
15509     } catch (...) {
15510       {
15511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15512       };
15513     }
15514   }
15515   jresult = result;
15516   return jresult;
15517 }
15518
15519
15520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15521   unsigned int jresult ;
15522   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15523   Dali::Vector2 *arg2 = 0 ;
15524   bool result;
15525
15526   arg1 = (Dali::Property::Value *)jarg1;
15527   arg2 = (Dali::Vector2 *)jarg2;
15528   if (!arg2) {
15529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15530     return 0;
15531   }
15532   {
15533     try {
15534       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15535     } catch (std::out_of_range& e) {
15536       {
15537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15538       };
15539     } catch (std::exception& e) {
15540       {
15541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15542       };
15543     } catch (...) {
15544       {
15545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15546       };
15547     }
15548   }
15549   jresult = result;
15550   return jresult;
15551 }
15552
15553
15554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15555   unsigned int jresult ;
15556   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15557   Dali::Vector3 *arg2 = 0 ;
15558   bool result;
15559
15560   arg1 = (Dali::Property::Value *)jarg1;
15561   arg2 = (Dali::Vector3 *)jarg2;
15562   if (!arg2) {
15563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15564     return 0;
15565   }
15566   {
15567     try {
15568       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15569     } catch (std::out_of_range& e) {
15570       {
15571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15572       };
15573     } catch (std::exception& e) {
15574       {
15575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15576       };
15577     } catch (...) {
15578       {
15579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15580       };
15581     }
15582   }
15583   jresult = result;
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15591   Dali::Vector4 *arg2 = 0 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Value *)jarg1;
15595   arg2 = (Dali::Vector4 *)jarg2;
15596   if (!arg2) {
15597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15598     return 0;
15599   }
15600   {
15601     try {
15602       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15603     } catch (std::out_of_range& e) {
15604       {
15605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (std::exception& e) {
15608       {
15609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15625   Dali::Matrix3 *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Value *)jarg1;
15629   arg2 = (Dali::Matrix3 *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (...) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15648       };
15649     }
15650   }
15651   jresult = result;
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15657   unsigned int jresult ;
15658   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15659   Dali::Matrix *arg2 = 0 ;
15660   bool result;
15661
15662   arg1 = (Dali::Property::Value *)jarg1;
15663   arg2 = (Dali::Matrix *)jarg2;
15664   if (!arg2) {
15665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15666     return 0;
15667   }
15668   {
15669     try {
15670       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15671     } catch (std::out_of_range& e) {
15672       {
15673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (std::exception& e) {
15676       {
15677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (...) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15682       };
15683     }
15684   }
15685   jresult = result;
15686   return jresult;
15687 }
15688
15689
15690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15691   unsigned int jresult ;
15692   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15693   Dali::AngleAxis *arg2 = 0 ;
15694   bool result;
15695
15696   arg1 = (Dali::Property::Value *)jarg1;
15697   arg2 = (Dali::AngleAxis *)jarg2;
15698   if (!arg2) {
15699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15700     return 0;
15701   }
15702   {
15703     try {
15704       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15705     } catch (std::out_of_range& e) {
15706       {
15707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15708       };
15709     } catch (std::exception& e) {
15710       {
15711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (...) {
15714       {
15715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15716       };
15717     }
15718   }
15719   jresult = result;
15720   return jresult;
15721 }
15722
15723
15724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15725   unsigned int jresult ;
15726   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15727   Dali::Quaternion *arg2 = 0 ;
15728   bool result;
15729
15730   arg1 = (Dali::Property::Value *)jarg1;
15731   arg2 = (Dali::Quaternion *)jarg2;
15732   if (!arg2) {
15733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15734     return 0;
15735   }
15736   {
15737     try {
15738       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15739     } catch (std::out_of_range& e) {
15740       {
15741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15742       };
15743     } catch (std::exception& e) {
15744       {
15745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15746       };
15747     } catch (...) {
15748       {
15749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15750       };
15751     }
15752   }
15753   jresult = result;
15754   return jresult;
15755 }
15756
15757
15758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15759   unsigned int jresult ;
15760   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15761   std::string *arg2 = 0 ;
15762   bool result;
15763
15764   arg1 = (Dali::Property::Value *)jarg1;
15765
15766   //typemap in
15767   std::string temp;
15768   arg2 = &temp;
15769
15770   {
15771     try {
15772       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15773     } catch (std::out_of_range& e) {
15774       {
15775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15776       };
15777     } catch (std::exception& e) {
15778       {
15779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15780       };
15781     } catch (...) {
15782       {
15783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15784       };
15785     }
15786   }
15787   jresult = result;
15788
15789   //Typemap argout in c++ file.
15790   //This will convert c++ string to c# string
15791   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15792
15793   return jresult;
15794 }
15795
15796
15797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15798   unsigned int jresult ;
15799   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15800   Dali::Property::Array *arg2 = 0 ;
15801   bool result;
15802
15803   arg1 = (Dali::Property::Value *)jarg1;
15804   arg2 = (Dali::Property::Array *)jarg2;
15805   if (!arg2) {
15806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15807     return 0;
15808   }
15809   {
15810     try {
15811       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15812     } catch (std::out_of_range& e) {
15813       {
15814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15815       };
15816     } catch (std::exception& e) {
15817       {
15818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15819       };
15820     } catch (...) {
15821       {
15822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15823       };
15824     }
15825   }
15826   jresult = result;
15827   return jresult;
15828 }
15829
15830
15831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15832   unsigned int jresult ;
15833   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15834   Dali::Property::Map *arg2 = 0 ;
15835   bool result;
15836
15837   arg1 = (Dali::Property::Value *)jarg1;
15838   arg2 = (Dali::Property::Map *)jarg2;
15839   if (!arg2) {
15840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15841     return 0;
15842   }
15843   {
15844     try {
15845       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15846     } catch (std::out_of_range& e) {
15847       {
15848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15849       };
15850     } catch (std::exception& e) {
15851       {
15852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (...) {
15855       {
15856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15857       };
15858     }
15859   }
15860   jresult = result;
15861   return jresult;
15862 }
15863
15864
15865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15866   void * jresult ;
15867   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15868   Dali::Property::Array *result = 0 ;
15869
15870   arg1 = (Dali::Property::Value *)jarg1;
15871   {
15872     try {
15873       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15874     } catch (std::out_of_range& e) {
15875       {
15876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15877       };
15878     } catch (std::exception& e) {
15879       {
15880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15881       };
15882     } catch (...) {
15883       {
15884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15885       };
15886     }
15887   }
15888   jresult = (void *)result;
15889   return jresult;
15890 }
15891
15892
15893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15894   void * jresult ;
15895   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15896   Dali::Property::Map *result = 0 ;
15897
15898   arg1 = (Dali::Property::Value *)jarg1;
15899   {
15900     try {
15901       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15902     } catch (std::out_of_range& e) {
15903       {
15904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (std::exception& e) {
15907       {
15908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15909       };
15910     } catch (...) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15913       };
15914     }
15915   }
15916   jresult = (void *)result;
15917   return jresult;
15918 }
15919
15920
15921 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15922   char * jresult ;
15923   Dali::Property::Type arg1 ;
15924   char *result = 0 ;
15925
15926   arg1 = (Dali::Property::Type)jarg1;
15927   {
15928     try {
15929       result = (char *)Dali::PropertyTypes::GetName(arg1);
15930     } catch (std::out_of_range& e) {
15931       {
15932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15933       };
15934     } catch (std::exception& e) {
15935       {
15936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15937       };
15938     } catch (...) {
15939       {
15940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15941       };
15942     }
15943   }
15944   jresult = SWIG_csharp_string_callback((const char *)result);
15945   return jresult;
15946 }
15947
15948
15949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15950   unsigned int jresult ;
15951   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15952   std::string *arg2 = 0 ;
15953   Dali::Property::Map *arg3 = 0 ;
15954   bool result;
15955
15956   arg1 = (Dali::BaseObject *)jarg1;
15957   if (!jarg2) {
15958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15959     return 0;
15960   }
15961   std::string arg2_str(jarg2);
15962   arg2 = &arg2_str;
15963   arg3 = (Dali::Property::Map *)jarg3;
15964   if (!arg3) {
15965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15966     return 0;
15967   }
15968   {
15969     try {
15970       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15971     } catch (std::out_of_range& e) {
15972       {
15973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15974       };
15975     } catch (std::exception& e) {
15976       {
15977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15978       };
15979     } catch (...) {
15980       {
15981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15982       };
15983     }
15984   }
15985   jresult = result;
15986
15987   //argout typemap for const std::string&
15988
15989   return jresult;
15990 }
15991
15992
15993 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15994   char * jresult ;
15995   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15996   std::string *result = 0 ;
15997
15998   arg1 = (Dali::BaseObject *)jarg1;
15999   {
16000     try {
16001       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16002     } catch (std::out_of_range& e) {
16003       {
16004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16005       };
16006     } catch (std::exception& e) {
16007       {
16008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16009       };
16010     } catch (...) {
16011       {
16012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16013       };
16014     }
16015   }
16016   jresult = SWIG_csharp_string_callback(result->c_str());
16017   return jresult;
16018 }
16019
16020
16021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16022   unsigned int jresult ;
16023   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16024   Dali::TypeInfo *arg2 = 0 ;
16025   bool result;
16026
16027   arg1 = (Dali::BaseObject *)jarg1;
16028   arg2 = (Dali::TypeInfo *)jarg2;
16029   if (!arg2) {
16030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16031     return 0;
16032   }
16033   {
16034     try {
16035       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16036     } catch (std::out_of_range& e) {
16037       {
16038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16039       };
16040     } catch (std::exception& e) {
16041       {
16042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16043       };
16044     } catch (...) {
16045       {
16046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16047       };
16048     }
16049   }
16050   jresult = result;
16051   return jresult;
16052 }
16053
16054
16055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16056   unsigned int jresult ;
16057   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16058   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16059   std::string *arg3 = 0 ;
16060   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16061   bool result;
16062
16063   arg1 = (Dali::BaseObject *)jarg1;
16064   arg2 = (ConnectionTrackerInterface *)jarg2;
16065   if (!jarg3) {
16066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16067     return 0;
16068   }
16069   std::string arg3_str(jarg3);
16070   arg3 = &arg3_str;
16071   arg4 = (FunctorDelegate *)jarg4;
16072   {
16073     try {
16074       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16075     } catch (std::out_of_range& e) {
16076       {
16077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16078       };
16079     } catch (std::exception& e) {
16080       {
16081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16082       };
16083     } catch (...) {
16084       {
16085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16086       };
16087     }
16088   }
16089   jresult = result;
16090
16091   //argout typemap for const std::string&
16092
16093   return jresult;
16094 }
16095
16096
16097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16098   void * jresult ;
16099   Dali::BaseHandle *arg1 = 0 ;
16100   Dali::BaseObject *result = 0 ;
16101
16102   arg1 = (Dali::BaseHandle *)jarg1;
16103   if (!arg1) {
16104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16105     return 0;
16106   }
16107   {
16108     try {
16109       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16110     } catch (std::out_of_range& e) {
16111       {
16112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16113       };
16114     } catch (std::exception& e) {
16115       {
16116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16117       };
16118     } catch (...) {
16119       {
16120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16121       };
16122     }
16123   }
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16130   void * jresult ;
16131   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16132   Dali::BaseHandle *result = 0 ;
16133
16134   arg1 = (Dali::BaseObject *)jarg1;
16135   {
16136     try {
16137       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (...) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16149       };
16150     }
16151   }
16152   jresult = (void *)result;
16153   return jresult;
16154 }
16155
16156
16157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16158   void * jresult ;
16159   Dali::BaseHandle *result = 0 ;
16160
16161   {
16162     try {
16163       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16164     } catch (std::out_of_range& e) {
16165       {
16166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16167       };
16168     } catch (std::exception& e) {
16169       {
16170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16171       };
16172     } catch (...) {
16173       {
16174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16175       };
16176     }
16177   }
16178   jresult = (void *)result;
16179   return jresult;
16180 }
16181
16182
16183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16184   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16185
16186   arg1 = (Dali::BaseHandle *)jarg1;
16187   {
16188     try {
16189       delete arg1;
16190     } catch (std::out_of_range& e) {
16191       {
16192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16193       };
16194     } catch (std::exception& e) {
16195       {
16196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16197       };
16198     } catch (...) {
16199       {
16200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16201       };
16202     }
16203   }
16204 }
16205
16206
16207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16208   void * jresult ;
16209   Dali::BaseHandle *arg1 = 0 ;
16210   Dali::BaseHandle *result = 0 ;
16211
16212   arg1 = (Dali::BaseHandle *)jarg1;
16213   if (!arg1) {
16214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16215     return 0;
16216   }
16217   {
16218     try {
16219       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16220     } catch (std::out_of_range& e) {
16221       {
16222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16223       };
16224     } catch (std::exception& e) {
16225       {
16226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16227       };
16228     } catch (...) {
16229       {
16230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16231       };
16232     }
16233   }
16234   jresult = (void *)result;
16235   return jresult;
16236 }
16237
16238
16239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16240   void * jresult ;
16241   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16242   Dali::BaseHandle *arg2 = 0 ;
16243   Dali::BaseHandle *result = 0 ;
16244
16245   arg1 = (Dali::BaseHandle *)jarg1;
16246   arg2 = (Dali::BaseHandle *)jarg2;
16247   if (!arg2) {
16248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16249     return 0;
16250   }
16251   {
16252     try {
16253       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16254     } catch (std::out_of_range& e) {
16255       {
16256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16257       };
16258     } catch (std::exception& e) {
16259       {
16260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16261       };
16262     } catch (...) {
16263       {
16264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16265       };
16266     }
16267   }
16268   jresult = (void *)result;
16269   return jresult;
16270 }
16271
16272
16273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16274   unsigned int jresult ;
16275   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16276   std::string *arg2 = 0 ;
16277   Dali::Property::Map *arg3 = 0 ;
16278   bool result;
16279
16280   arg1 = (Dali::BaseHandle *)jarg1;
16281   if (!jarg2) {
16282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16283     return 0;
16284   }
16285   std::string arg2_str(jarg2);
16286   arg2 = &arg2_str;
16287   arg3 = (Dali::Property::Map *)jarg3;
16288   if (!arg3) {
16289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16290     return 0;
16291   }
16292   {
16293     try {
16294       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16295     } catch (std::out_of_range& e) {
16296       {
16297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16298       };
16299     } catch (std::exception& e) {
16300       {
16301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16302       };
16303     } catch (...) {
16304       {
16305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16306       };
16307     }
16308   }
16309   jresult = result;
16310
16311   //argout typemap for const std::string&
16312
16313   return jresult;
16314 }
16315
16316
16317 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16318   char * jresult ;
16319   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16320   std::string *result = 0 ;
16321
16322   arg1 = (Dali::BaseHandle *)jarg1;
16323   {
16324     try {
16325       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16326     } catch (std::out_of_range& e) {
16327       {
16328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16329       };
16330     } catch (std::exception& e) {
16331       {
16332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16333       };
16334     } catch (...) {
16335       {
16336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16337       };
16338     }
16339   }
16340   jresult = SWIG_csharp_string_callback(result->c_str());
16341   return jresult;
16342 }
16343
16344
16345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16346   unsigned int jresult ;
16347   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16348   Dali::TypeInfo *arg2 = 0 ;
16349   bool result;
16350
16351   arg1 = (Dali::BaseHandle *)jarg1;
16352   arg2 = (Dali::TypeInfo *)jarg2;
16353   if (!arg2) {
16354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16355     return 0;
16356   }
16357   {
16358     try {
16359       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16360     } catch (std::out_of_range& e) {
16361       {
16362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16363       };
16364     } catch (std::exception& e) {
16365       {
16366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (...) {
16369       {
16370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16371       };
16372     }
16373   }
16374   jresult = result;
16375   return jresult;
16376 }
16377
16378
16379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16380   void * jresult ;
16381   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16382   Dali::BaseObject *result = 0 ;
16383
16384   arg1 = (Dali::BaseHandle *)jarg1;
16385   {
16386     try {
16387       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16388     } catch (std::out_of_range& e) {
16389       {
16390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16391       };
16392     } catch (std::exception& e) {
16393       {
16394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16395       };
16396     } catch (...) {
16397       {
16398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16399       };
16400     }
16401   }
16402   jresult = (void *)result;
16403   return jresult;
16404 }
16405
16406
16407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16408   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16409
16410   arg1 = (Dali::BaseHandle *)jarg1;
16411   {
16412     try {
16413       (arg1)->Reset();
16414     } catch (std::out_of_range& e) {
16415       {
16416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16417       };
16418     } catch (std::exception& e) {
16419       {
16420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16421       };
16422     } catch (...) {
16423       {
16424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16425       };
16426     }
16427   }
16428 }
16429
16430
16431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16432   unsigned int jresult ;
16433   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16434   Dali::BaseHandle *arg2 = 0 ;
16435   bool result;
16436
16437   arg1 = (Dali::BaseHandle *)jarg1;
16438   arg2 = (Dali::BaseHandle *)jarg2;
16439   if (!arg2) {
16440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16441     return 0;
16442   }
16443   {
16444     try {
16445       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16446     } catch (std::out_of_range& e) {
16447       {
16448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (std::exception& e) {
16451       {
16452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460   jresult = result;
16461   return jresult;
16462 }
16463
16464
16465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16466   unsigned int jresult ;
16467   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16468   Dali::BaseHandle *arg2 = 0 ;
16469   bool result;
16470
16471   arg1 = (Dali::BaseHandle *)jarg1;
16472   arg2 = (Dali::BaseHandle *)jarg2;
16473   if (!arg2) {
16474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16475     return 0;
16476   }
16477   {
16478     try {
16479       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16480     } catch (std::out_of_range& e) {
16481       {
16482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16483       };
16484     } catch (std::exception& e) {
16485       {
16486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16487       };
16488     } catch (...) {
16489       {
16490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16491       };
16492     }
16493   }
16494   jresult = result;
16495   return jresult;
16496 }
16497
16498
16499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16500   void * jresult ;
16501   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16502   Dali::RefObject *result = 0 ;
16503
16504   arg1 = (Dali::BaseHandle *)jarg1;
16505   {
16506     try {
16507       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16515       };
16516     } catch (...) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16519       };
16520     }
16521   }
16522   jresult = (void *)result;
16523   return jresult;
16524 }
16525
16526
16527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16528   unsigned int jresult ;
16529   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16530   bool result;
16531
16532   arg1 = (Dali::BaseHandle *)jarg1;
16533   {
16534     try {
16535       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16536     } catch (std::out_of_range& e) {
16537       {
16538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16539       };
16540     } catch (std::exception& e) {
16541       {
16542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16543       };
16544     } catch (...) {
16545       {
16546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16547       };
16548     }
16549   }
16550   jresult = result;
16551   return jresult;
16552 }
16553
16554
16555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16556   unsigned int jresult ;
16557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16558   Dali::BaseHandle *arg2 = 0 ;
16559   bool result;
16560
16561   arg1 = (Dali::BaseHandle *)jarg1;
16562   arg2 = (Dali::BaseHandle *)jarg2;
16563   if (!arg2) {
16564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16565     return 0;
16566   }
16567   {
16568     try {
16569       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16570     } catch (std::out_of_range& e) {
16571       {
16572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16573       };
16574     } catch (std::exception& e) {
16575       {
16576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16577       };
16578     } catch (...) {
16579       {
16580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16581       };
16582     }
16583   }
16584   jresult = result;
16585   return jresult;
16586 }
16587
16588
16589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16590   unsigned int jresult ;
16591   Dali::BaseHandle *arg1 = 0 ;
16592   Dali::BaseHandle *arg2 = 0 ;
16593   bool result;
16594
16595   arg1 = (Dali::BaseHandle *)jarg1;
16596   if (!arg1) {
16597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16598     return 0;
16599   }
16600   arg2 = (Dali::BaseHandle *)jarg2;
16601   if (!arg2) {
16602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16603     return 0;
16604   }
16605   {
16606     try {
16607       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16608     } catch (std::out_of_range& e) {
16609       {
16610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16611       };
16612     } catch (std::exception& e) {
16613       {
16614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16615       };
16616     } catch (...) {
16617       {
16618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16619       };
16620     }
16621   }
16622   jresult = result;
16623   return jresult;
16624 }
16625
16626
16627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16628   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16629
16630   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16631   {
16632     try {
16633       delete arg1;
16634     } catch (std::out_of_range& e) {
16635       {
16636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16637       };
16638     } catch (std::exception& e) {
16639       {
16640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16641       };
16642     } catch (...) {
16643       {
16644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16645       };
16646     }
16647   }
16648 }
16649
16650
16651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16652   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16653   SlotObserver *arg2 = (SlotObserver *) 0 ;
16654   CallbackBase *arg3 = (CallbackBase *) 0 ;
16655
16656   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16657   arg2 = (SlotObserver *)jarg2;
16658   arg3 = (CallbackBase *)jarg3;
16659   {
16660     try {
16661       (arg1)->SignalConnected(arg2,arg3);
16662     } catch (std::out_of_range& e) {
16663       {
16664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16665       };
16666     } catch (std::exception& e) {
16667       {
16668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16669       };
16670     } catch (...) {
16671       {
16672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16673       };
16674     }
16675   }
16676 }
16677
16678
16679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16680   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16681
16682   arg1 = (Dali::SignalObserver *)jarg1;
16683   {
16684     try {
16685       delete arg1;
16686     } catch (std::out_of_range& e) {
16687       {
16688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16689       };
16690     } catch (std::exception& e) {
16691       {
16692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16693       };
16694     } catch (...) {
16695       {
16696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16697       };
16698     }
16699   }
16700 }
16701
16702
16703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16704   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16705   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16706   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16707
16708   arg1 = (Dali::SignalObserver *)jarg1;
16709   arg2 = (Dali::SlotObserver *)jarg2;
16710   arg3 = (Dali::CallbackBase *)jarg3;
16711   {
16712     try {
16713       (arg1)->SignalDisconnected(arg2,arg3);
16714     } catch (std::out_of_range& e) {
16715       {
16716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16717       };
16718     } catch (std::exception& e) {
16719       {
16720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16721       };
16722     } catch (...) {
16723       {
16724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16725       };
16726     }
16727   }
16728 }
16729
16730
16731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16732   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16733
16734   arg1 = (Dali::SlotObserver *)jarg1;
16735   {
16736     try {
16737       delete arg1;
16738     } catch (std::out_of_range& e) {
16739       {
16740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16741       };
16742     } catch (std::exception& e) {
16743       {
16744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16745       };
16746     } catch (...) {
16747       {
16748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16749       };
16750     }
16751   }
16752 }
16753
16754
16755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16756   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16757   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16758
16759   arg1 = (Dali::SlotObserver *)jarg1;
16760   arg2 = (Dali::CallbackBase *)jarg2;
16761   {
16762     try {
16763       (arg1)->SlotDisconnected(arg2);
16764     } catch (std::out_of_range& e) {
16765       {
16766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16767       };
16768     } catch (std::exception& e) {
16769       {
16770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16771       };
16772     } catch (...) {
16773       {
16774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16775       };
16776     }
16777   }
16778 }
16779
16780
16781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16782   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16783
16784   arg1 = (Dali::ConnectionTracker *)jarg1;
16785   {
16786     try {
16787       delete arg1;
16788     } catch (std::out_of_range& e) {
16789       {
16790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16791       };
16792     } catch (std::exception& e) {
16793       {
16794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16795       };
16796     } catch (...) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16799       };
16800     }
16801   }
16802 }
16803
16804
16805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16806   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16807
16808   arg1 = (Dali::ConnectionTracker *)jarg1;
16809   {
16810     try {
16811       (arg1)->DisconnectAll();
16812     } catch (std::out_of_range& e) {
16813       {
16814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16815       };
16816     } catch (std::exception& e) {
16817       {
16818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16823       };
16824     }
16825   }
16826 }
16827
16828
16829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16830   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16831   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16832   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16833
16834   arg1 = (Dali::ConnectionTracker *)jarg1;
16835   arg2 = (Dali::SlotObserver *)jarg2;
16836   arg3 = (Dali::CallbackBase *)jarg3;
16837   {
16838     try {
16839       (arg1)->SignalConnected(arg2,arg3);
16840     } catch (std::out_of_range& e) {
16841       {
16842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16843       };
16844     } catch (std::exception& e) {
16845       {
16846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16847       };
16848     } catch (...) {
16849       {
16850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16851       };
16852     }
16853   }
16854 }
16855
16856
16857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16858   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16859   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16860   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16861
16862   arg1 = (Dali::ConnectionTracker *)jarg1;
16863   arg2 = (Dali::SlotObserver *)jarg2;
16864   arg3 = (Dali::CallbackBase *)jarg3;
16865   {
16866     try {
16867       (arg1)->SignalDisconnected(arg2,arg3);
16868     } catch (std::out_of_range& e) {
16869       {
16870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16871       };
16872     } catch (std::exception& e) {
16873       {
16874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16875       };
16876     } catch (...) {
16877       {
16878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16879       };
16880     }
16881   }
16882 }
16883
16884
16885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16886   unsigned long jresult ;
16887   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16888   std::size_t result;
16889
16890   arg1 = (Dali::ConnectionTracker *)jarg1;
16891   {
16892     try {
16893       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16894     } catch (std::out_of_range& e) {
16895       {
16896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16897       };
16898     } catch (std::exception& e) {
16899       {
16900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (...) {
16903       {
16904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16905       };
16906     }
16907   }
16908   jresult = (unsigned long)result;
16909   return jresult;
16910 }
16911
16912
16913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16914   void * jresult ;
16915   Dali::ObjectRegistry *result = 0 ;
16916
16917   {
16918     try {
16919       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16920     } catch (std::out_of_range& e) {
16921       {
16922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16923       };
16924     } catch (std::exception& e) {
16925       {
16926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16927       };
16928     } catch (...) {
16929       {
16930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16931       };
16932     }
16933   }
16934   jresult = (void *)result;
16935   return jresult;
16936 }
16937
16938
16939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16940   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16941
16942   arg1 = (Dali::ObjectRegistry *)jarg1;
16943   {
16944     try {
16945       delete arg1;
16946     } catch (std::out_of_range& e) {
16947       {
16948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16949       };
16950     } catch (std::exception& e) {
16951       {
16952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16953       };
16954     } catch (...) {
16955       {
16956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16957       };
16958     }
16959   }
16960 }
16961
16962
16963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16964   void * jresult ;
16965   Dali::ObjectRegistry *arg1 = 0 ;
16966   Dali::ObjectRegistry *result = 0 ;
16967
16968   arg1 = (Dali::ObjectRegistry *)jarg1;
16969   if (!arg1) {
16970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16971     return 0;
16972   }
16973   {
16974     try {
16975       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16976     } catch (std::out_of_range& e) {
16977       {
16978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (std::exception& e) {
16981       {
16982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990   jresult = (void *)result;
16991   return jresult;
16992 }
16993
16994
16995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16996   void * jresult ;
16997   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16998   Dali::ObjectRegistry *arg2 = 0 ;
16999   Dali::ObjectRegistry *result = 0 ;
17000
17001   arg1 = (Dali::ObjectRegistry *)jarg1;
17002   arg2 = (Dali::ObjectRegistry *)jarg2;
17003   if (!arg2) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024   jresult = (void *)result;
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17030   void * jresult ;
17031   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17032   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17033
17034   arg1 = (Dali::ObjectRegistry *)jarg1;
17035   {
17036     try {
17037       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17038     } catch (std::out_of_range& e) {
17039       {
17040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17041       };
17042     } catch (std::exception& e) {
17043       {
17044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17045       };
17046     } catch (...) {
17047       {
17048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17049       };
17050     }
17051   }
17052   jresult = (void *)result;
17053   return jresult;
17054 }
17055
17056
17057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17058   void * jresult ;
17059   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17060   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17061
17062   arg1 = (Dali::ObjectRegistry *)jarg1;
17063   {
17064     try {
17065       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (...) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17077       };
17078     }
17079   }
17080   jresult = (void *)result;
17081   return jresult;
17082 }
17083
17084
17085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17086   void * jresult ;
17087   Dali::PropertyCondition *result = 0 ;
17088
17089   {
17090     try {
17091       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17092     } catch (std::out_of_range& e) {
17093       {
17094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17095       };
17096     } catch (std::exception& e) {
17097       {
17098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17099       };
17100     } catch (...) {
17101       {
17102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17103       };
17104     }
17105   }
17106   jresult = (void *)result;
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17112   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17113
17114   arg1 = (Dali::PropertyCondition *)jarg1;
17115   {
17116     try {
17117       delete arg1;
17118     } catch (std::out_of_range& e) {
17119       {
17120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17121       };
17122     } catch (std::exception& e) {
17123       {
17124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17125       };
17126     } catch (...) {
17127       {
17128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17129       };
17130     }
17131   }
17132 }
17133
17134
17135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17136   void * jresult ;
17137   Dali::PropertyCondition *arg1 = 0 ;
17138   Dali::PropertyCondition *result = 0 ;
17139
17140   arg1 = (Dali::PropertyCondition *)jarg1;
17141   if (!arg1) {
17142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17143     return 0;
17144   }
17145   {
17146     try {
17147       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17148     } catch (std::out_of_range& e) {
17149       {
17150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17151       };
17152     } catch (std::exception& e) {
17153       {
17154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17155       };
17156     } catch (...) {
17157       {
17158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17159       };
17160     }
17161   }
17162   jresult = (void *)result;
17163   return jresult;
17164 }
17165
17166
17167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17168   void * jresult ;
17169   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17170   Dali::PropertyCondition *arg2 = 0 ;
17171   Dali::PropertyCondition *result = 0 ;
17172
17173   arg1 = (Dali::PropertyCondition *)jarg1;
17174   arg2 = (Dali::PropertyCondition *)jarg2;
17175   if (!arg2) {
17176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17177     return 0;
17178   }
17179   {
17180     try {
17181       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17182     } catch (std::out_of_range& e) {
17183       {
17184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (std::exception& e) {
17187       {
17188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (...) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17193       };
17194     }
17195   }
17196   jresult = (void *)result;
17197   return jresult;
17198 }
17199
17200
17201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17202   unsigned long jresult ;
17203   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17204   std::size_t result;
17205
17206   arg1 = (Dali::PropertyCondition *)jarg1;
17207   {
17208     try {
17209       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17210     } catch (std::out_of_range& e) {
17211       {
17212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17213       };
17214     } catch (std::exception& e) {
17215       {
17216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17217       };
17218     } catch (...) {
17219       {
17220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17221       };
17222     }
17223   }
17224   jresult = (unsigned long)result;
17225   return jresult;
17226 }
17227
17228
17229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17230   float jresult ;
17231   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17232   std::size_t arg2 ;
17233   float result;
17234
17235   arg1 = (Dali::PropertyCondition *)jarg1;
17236   arg2 = (std::size_t)jarg2;
17237   {
17238     try {
17239       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17240     } catch (std::out_of_range& e) {
17241       {
17242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17243       };
17244     } catch (std::exception& e) {
17245       {
17246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17247       };
17248     } catch (...) {
17249       {
17250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17251       };
17252     }
17253   }
17254   jresult = result;
17255   return jresult;
17256 }
17257
17258
17259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17260   void * jresult ;
17261   float arg1 ;
17262   Dali::PropertyCondition result;
17263
17264   arg1 = (float)jarg1;
17265   {
17266     try {
17267       result = Dali::LessThanCondition(arg1);
17268     } catch (std::out_of_range& e) {
17269       {
17270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (std::exception& e) {
17273       {
17274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17288   void * jresult ;
17289   float arg1 ;
17290   Dali::PropertyCondition result;
17291
17292   arg1 = (float)jarg1;
17293   {
17294     try {
17295       result = Dali::GreaterThanCondition(arg1);
17296     } catch (std::out_of_range& e) {
17297       {
17298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17299       };
17300     } catch (std::exception& e) {
17301       {
17302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17303       };
17304     } catch (...) {
17305       {
17306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17307       };
17308     }
17309   }
17310   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17311   return jresult;
17312 }
17313
17314
17315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17316   void * jresult ;
17317   float arg1 ;
17318   float arg2 ;
17319   Dali::PropertyCondition result;
17320
17321   arg1 = (float)jarg1;
17322   arg2 = (float)jarg2;
17323   {
17324     try {
17325       result = Dali::InsideCondition(arg1,arg2);
17326     } catch (std::out_of_range& e) {
17327       {
17328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17329       };
17330     } catch (std::exception& e) {
17331       {
17332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17333       };
17334     } catch (...) {
17335       {
17336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17337       };
17338     }
17339   }
17340   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17341   return jresult;
17342 }
17343
17344
17345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17346   void * jresult ;
17347   float arg1 ;
17348   float arg2 ;
17349   Dali::PropertyCondition result;
17350
17351   arg1 = (float)jarg1;
17352   arg2 = (float)jarg2;
17353   {
17354     try {
17355       result = Dali::OutsideCondition(arg1,arg2);
17356     } catch (std::out_of_range& e) {
17357       {
17358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17359       };
17360     } catch (std::exception& e) {
17361       {
17362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17363       };
17364     } catch (...) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17367       };
17368     }
17369   }
17370   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17371   return jresult;
17372 }
17373
17374
17375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17376   void * jresult ;
17377   float arg1 ;
17378   float arg2 ;
17379   Dali::PropertyCondition result;
17380
17381   arg1 = (float)jarg1;
17382   arg2 = (float)jarg2;
17383   {
17384     try {
17385       result = Dali::StepCondition(arg1,arg2);
17386     } catch (std::out_of_range& e) {
17387       {
17388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17389       };
17390     } catch (std::exception& e) {
17391       {
17392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17393       };
17394     } catch (...) {
17395       {
17396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17397       };
17398     }
17399   }
17400   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17401   return jresult;
17402 }
17403
17404
17405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17406   void * jresult ;
17407   float arg1 ;
17408   Dali::PropertyCondition result;
17409
17410   arg1 = (float)jarg1;
17411   {
17412     try {
17413       result = Dali::StepCondition(arg1);
17414     } catch (std::out_of_range& e) {
17415       {
17416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17417       };
17418     } catch (std::exception& e) {
17419       {
17420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17421       };
17422     } catch (...) {
17423       {
17424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17425       };
17426     }
17427   }
17428   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17429   return jresult;
17430 }
17431
17432
17433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17434   void * jresult ;
17435   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17436   Dali::PropertyCondition result;
17437
17438   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17439   if (!arg1) {
17440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17441     return 0;
17442   }
17443   {
17444     try {
17445       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17446     } catch (std::out_of_range& e) {
17447       {
17448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17449       };
17450     } catch (std::exception& e) {
17451       {
17452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17453       };
17454     } catch (...) {
17455       {
17456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17457       };
17458     }
17459   }
17460   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17461   return jresult;
17462 }
17463
17464
17465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17466   void * jresult ;
17467   Dali::PropertyNotification *result = 0 ;
17468
17469   {
17470     try {
17471       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (...) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17483       };
17484     }
17485   }
17486   jresult = (void *)result;
17487   return jresult;
17488 }
17489
17490
17491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17492   void * jresult ;
17493   Dali::BaseHandle arg1 ;
17494   Dali::BaseHandle *argp1 ;
17495   Dali::PropertyNotification result;
17496
17497   argp1 = (Dali::BaseHandle *)jarg1;
17498   if (!argp1) {
17499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17500     return 0;
17501   }
17502   arg1 = *argp1;
17503   {
17504     try {
17505       result = Dali::PropertyNotification::DownCast(arg1);
17506     } catch (std::out_of_range& e) {
17507       {
17508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17509       };
17510     } catch (std::exception& e) {
17511       {
17512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (...) {
17515       {
17516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17517       };
17518     }
17519   }
17520   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17521   return jresult;
17522 }
17523
17524
17525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17526   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17527
17528   arg1 = (Dali::PropertyNotification *)jarg1;
17529   {
17530     try {
17531       delete arg1;
17532     } catch (std::out_of_range& e) {
17533       {
17534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17535       };
17536     } catch (std::exception& e) {
17537       {
17538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17539       };
17540     } catch (...) {
17541       {
17542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17543       };
17544     }
17545   }
17546 }
17547
17548
17549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17550   void * jresult ;
17551   Dali::PropertyNotification *arg1 = 0 ;
17552   Dali::PropertyNotification *result = 0 ;
17553
17554   arg1 = (Dali::PropertyNotification *)jarg1;
17555   if (!arg1) {
17556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17557     return 0;
17558   }
17559   {
17560     try {
17561       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17562     } catch (std::out_of_range& e) {
17563       {
17564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17565       };
17566     } catch (std::exception& e) {
17567       {
17568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (...) {
17571       {
17572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17573       };
17574     }
17575   }
17576   jresult = (void *)result;
17577   return jresult;
17578 }
17579
17580
17581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17582   void * jresult ;
17583   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17584   Dali::PropertyNotification *arg2 = 0 ;
17585   Dali::PropertyNotification *result = 0 ;
17586
17587   arg1 = (Dali::PropertyNotification *)jarg1;
17588   arg2 = (Dali::PropertyNotification *)jarg2;
17589   if (!arg2) {
17590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17591     return 0;
17592   }
17593   {
17594     try {
17595       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17596     } catch (std::out_of_range& e) {
17597       {
17598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17599       };
17600     } catch (std::exception& e) {
17601       {
17602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17603       };
17604     } catch (...) {
17605       {
17606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17607       };
17608     }
17609   }
17610   jresult = (void *)result;
17611   return jresult;
17612 }
17613
17614
17615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17616   void * jresult ;
17617   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17618   Dali::PropertyCondition result;
17619
17620   arg1 = (Dali::PropertyNotification *)jarg1;
17621   {
17622     try {
17623       result = (arg1)->GetCondition();
17624     } catch (std::out_of_range& e) {
17625       {
17626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (std::exception& e) {
17629       {
17630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (...) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17635       };
17636     }
17637   }
17638   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17639   return jresult;
17640 }
17641
17642
17643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17644   void * jresult ;
17645   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17646   Dali::Handle result;
17647
17648   arg1 = (Dali::PropertyNotification *)jarg1;
17649   {
17650     try {
17651       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17652     } catch (std::out_of_range& e) {
17653       {
17654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (std::exception& e) {
17657       {
17658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666   jresult = new Dali::Handle((const Dali::Handle &)result);
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17672   int jresult ;
17673   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17674   Dali::Property::Index result;
17675
17676   arg1 = (Dali::PropertyNotification *)jarg1;
17677   {
17678     try {
17679       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17680     } catch (std::out_of_range& e) {
17681       {
17682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17683       };
17684     } catch (std::exception& e) {
17685       {
17686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17687       };
17688     } catch (...) {
17689       {
17690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17691       };
17692     }
17693   }
17694   jresult = result;
17695   return jresult;
17696 }
17697
17698
17699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17700   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17701   Dali::PropertyNotification::NotifyMode arg2 ;
17702
17703   arg1 = (Dali::PropertyNotification *)jarg1;
17704   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17705   {
17706     try {
17707       (arg1)->SetNotifyMode(arg2);
17708     } catch (std::out_of_range& e) {
17709       {
17710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17711       };
17712     } catch (std::exception& e) {
17713       {
17714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17719       };
17720     }
17721   }
17722 }
17723
17724
17725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17726   int jresult ;
17727   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17728   Dali::PropertyNotification::NotifyMode result;
17729
17730   arg1 = (Dali::PropertyNotification *)jarg1;
17731   {
17732     try {
17733       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17734     } catch (std::out_of_range& e) {
17735       {
17736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17737       };
17738     } catch (std::exception& e) {
17739       {
17740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17741       };
17742     } catch (...) {
17743       {
17744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17745       };
17746     }
17747   }
17748   jresult = (int)result;
17749   return jresult;
17750 }
17751
17752
17753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17754   unsigned int jresult ;
17755   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17756   bool result;
17757
17758   arg1 = (Dali::PropertyNotification *)jarg1;
17759   {
17760     try {
17761       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17762     } catch (std::out_of_range& e) {
17763       {
17764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17765       };
17766     } catch (std::exception& e) {
17767       {
17768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17769       };
17770     } catch (...) {
17771       {
17772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17773       };
17774     }
17775   }
17776   jresult = result;
17777   return jresult;
17778 }
17779
17780
17781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17782   void * jresult ;
17783   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17784   Dali::PropertyNotifySignalType *result = 0 ;
17785
17786   arg1 = (Dali::PropertyNotification *)jarg1;
17787   {
17788     try {
17789       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17790     } catch (std::out_of_range& e) {
17791       {
17792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17793       };
17794     } catch (std::exception& e) {
17795       {
17796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17797       };
17798     } catch (...) {
17799       {
17800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17801       };
17802     }
17803   }
17804   jresult = (void *)result;
17805   return jresult;
17806 }
17807
17808
17809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17810   void * jresult ;
17811   Dali::Handle *result = 0 ;
17812
17813   {
17814     try {
17815       result = (Dali::Handle *)new Dali::Handle();
17816     } catch (std::out_of_range& e) {
17817       {
17818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17819       };
17820     } catch (std::exception& e) {
17821       {
17822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (...) {
17825       {
17826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17827       };
17828     }
17829   }
17830   jresult = (void *)result;
17831   return jresult;
17832 }
17833
17834
17835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17836   void * jresult ;
17837   Dali::Handle result;
17838
17839   {
17840     try {
17841       result = Dali::Handle::New();
17842     } catch (std::out_of_range& e) {
17843       {
17844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17845       };
17846     } catch (std::exception& e) {
17847       {
17848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17849       };
17850     } catch (...) {
17851       {
17852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17853       };
17854     }
17855   }
17856   jresult = new Dali::Handle((const Dali::Handle &)result);
17857   return jresult;
17858 }
17859
17860
17861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17862   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17863
17864   arg1 = (Dali::Handle *)jarg1;
17865   {
17866     try {
17867       delete arg1;
17868     } catch (std::out_of_range& e) {
17869       {
17870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17871       };
17872     } catch (std::exception& e) {
17873       {
17874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17875       };
17876     } catch (...) {
17877       {
17878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17879       };
17880     }
17881   }
17882 }
17883
17884
17885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17886   void * jresult ;
17887   Dali::Handle *arg1 = 0 ;
17888   Dali::Handle *result = 0 ;
17889
17890   arg1 = (Dali::Handle *)jarg1;
17891   if (!arg1) {
17892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17893     return 0;
17894   }
17895   {
17896     try {
17897       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17898     } catch (std::out_of_range& e) {
17899       {
17900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17901       };
17902     } catch (std::exception& e) {
17903       {
17904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17905       };
17906     } catch (...) {
17907       {
17908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17909       };
17910     }
17911   }
17912   jresult = (void *)result;
17913   return jresult;
17914 }
17915
17916
17917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17918   void * jresult ;
17919   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17920   Dali::Handle *arg2 = 0 ;
17921   Dali::Handle *result = 0 ;
17922
17923   arg1 = (Dali::Handle *)jarg1;
17924   arg2 = (Dali::Handle *)jarg2;
17925   if (!arg2) {
17926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17927     return 0;
17928   }
17929   {
17930     try {
17931       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17932     } catch (std::out_of_range& e) {
17933       {
17934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17935       };
17936     } catch (std::exception& e) {
17937       {
17938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17939       };
17940     } catch (...) {
17941       {
17942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17943       };
17944     }
17945   }
17946   jresult = (void *)result;
17947   return jresult;
17948 }
17949
17950
17951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17952   void * jresult ;
17953   Dali::BaseHandle arg1 ;
17954   Dali::BaseHandle *argp1 ;
17955   Dali::Handle result;
17956
17957   argp1 = (Dali::BaseHandle *)jarg1;
17958   if (!argp1) {
17959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17960     return 0;
17961   }
17962   arg1 = *argp1;
17963   {
17964     try {
17965       result = Dali::Handle::DownCast(arg1);
17966     } catch (std::out_of_range& e) {
17967       {
17968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17969       };
17970     } catch (std::exception& e) {
17971       {
17972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (...) {
17975       {
17976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17977       };
17978     }
17979   }
17980   jresult = new Dali::Handle((const Dali::Handle &)result);
17981   return jresult;
17982 }
17983
17984
17985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17986   unsigned int jresult ;
17987   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17988   Dali::Handle::Capability arg2 ;
17989   bool result;
17990
17991   arg1 = (Dali::Handle *)jarg1;
17992   arg2 = (Dali::Handle::Capability)jarg2;
17993   {
17994     try {
17995       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17996     } catch (std::out_of_range& e) {
17997       {
17998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17999       };
18000     } catch (std::exception& e) {
18001       {
18002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (...) {
18005       {
18006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18007       };
18008     }
18009   }
18010   jresult = result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18016   unsigned int jresult ;
18017   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18018   unsigned int result;
18019
18020   arg1 = (Dali::Handle *)jarg1;
18021   {
18022     try {
18023       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18024     } catch (std::out_of_range& e) {
18025       {
18026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (std::exception& e) {
18029       {
18030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18031       };
18032     } catch (...) {
18033       {
18034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18035       };
18036     }
18037   }
18038   jresult = result;
18039   return jresult;
18040 }
18041
18042
18043 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18044   char * jresult ;
18045   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18046   Dali::Property::Index arg2 ;
18047   std::string result;
18048
18049   arg1 = (Dali::Handle *)jarg1;
18050   arg2 = (Dali::Property::Index)jarg2;
18051   {
18052     try {
18053       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18054     } catch (std::out_of_range& e) {
18055       {
18056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18057       };
18058     } catch (std::exception& e) {
18059       {
18060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18061       };
18062     } catch (...) {
18063       {
18064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18065       };
18066     }
18067   }
18068   jresult = SWIG_csharp_string_callback((&result)->c_str());
18069   return jresult;
18070 }
18071
18072
18073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18074   int jresult ;
18075   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18076   std::string *arg2 = 0 ;
18077   Dali::Property::Index result;
18078
18079   arg1 = (Dali::Handle *)jarg1;
18080   if (!jarg2) {
18081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18082     return 0;
18083   }
18084   std::string arg2_str(jarg2);
18085   arg2 = &arg2_str;
18086   {
18087     try {
18088       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18089     } catch (std::out_of_range& e) {
18090       {
18091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (std::exception& e) {
18094       {
18095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18096       };
18097     } catch (...) {
18098       {
18099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18100       };
18101     }
18102   }
18103   jresult = result;
18104
18105   //argout typemap for const std::string&
18106
18107   return jresult;
18108 }
18109
18110
18111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18112   unsigned int jresult ;
18113   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18114   Dali::Property::Index arg2 ;
18115   bool result;
18116
18117   arg1 = (Dali::Handle *)jarg1;
18118   arg2 = (Dali::Property::Index)jarg2;
18119   {
18120     try {
18121       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18122     } catch (std::out_of_range& e) {
18123       {
18124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18125       };
18126     } catch (std::exception& e) {
18127       {
18128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18129       };
18130     } catch (...) {
18131       {
18132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18133       };
18134     }
18135   }
18136   jresult = result;
18137   return jresult;
18138 }
18139
18140
18141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18142   unsigned int jresult ;
18143   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18144   Dali::Property::Index arg2 ;
18145   bool result;
18146
18147   arg1 = (Dali::Handle *)jarg1;
18148   arg2 = (Dali::Property::Index)jarg2;
18149   {
18150     try {
18151       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18152     } catch (std::out_of_range& e) {
18153       {
18154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18155       };
18156     } catch (std::exception& e) {
18157       {
18158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18159       };
18160     } catch (...) {
18161       {
18162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18163       };
18164     }
18165   }
18166   jresult = result;
18167   return jresult;
18168 }
18169
18170
18171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18172   unsigned int jresult ;
18173   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18174   Dali::Property::Index arg2 ;
18175   bool result;
18176
18177   arg1 = (Dali::Handle *)jarg1;
18178   arg2 = (Dali::Property::Index)jarg2;
18179   {
18180     try {
18181       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18182     } catch (std::out_of_range& e) {
18183       {
18184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18185       };
18186     } catch (std::exception& e) {
18187       {
18188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18189       };
18190     } catch (...) {
18191       {
18192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18193       };
18194     }
18195   }
18196   jresult = result;
18197   return jresult;
18198 }
18199
18200
18201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18202   int jresult ;
18203   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18204   Dali::Property::Index arg2 ;
18205   Dali::Property::Type result;
18206
18207   arg1 = (Dali::Handle *)jarg1;
18208   arg2 = (Dali::Property::Index)jarg2;
18209   {
18210     try {
18211       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18212     } catch (std::out_of_range& e) {
18213       {
18214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18215       };
18216     } catch (std::exception& e) {
18217       {
18218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18219       };
18220     } catch (...) {
18221       {
18222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18223       };
18224     }
18225   }
18226   jresult = (int)result;
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18232   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18233   Dali::Property::Index arg2 ;
18234   Dali::Property::Value *arg3 = 0 ;
18235
18236   arg1 = (Dali::Handle *)jarg1;
18237   arg2 = (Dali::Property::Index)jarg2;
18238   arg3 = (Dali::Property::Value *)jarg3;
18239   if (!arg3) {
18240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18241     return ;
18242   }
18243   {
18244     try {
18245       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18246     } catch (std::out_of_range& e) {
18247       {
18248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18249       };
18250     } catch (std::exception& e) {
18251       {
18252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18253       };
18254     } catch (...) {
18255       {
18256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18257       };
18258     }
18259   }
18260 }
18261
18262
18263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18264   int jresult ;
18265   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18266   std::string *arg2 = 0 ;
18267   Dali::Property::Value *arg3 = 0 ;
18268   Dali::Property::Index result;
18269
18270   arg1 = (Dali::Handle *)jarg1;
18271   if (!jarg2) {
18272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18273     return 0;
18274   }
18275   std::string arg2_str(jarg2);
18276   arg2 = &arg2_str;
18277   arg3 = (Dali::Property::Value *)jarg3;
18278   if (!arg3) {
18279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18280     return 0;
18281   }
18282   {
18283     try {
18284       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18285     } catch (std::out_of_range& e) {
18286       {
18287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18288       };
18289     } catch (std::exception& e) {
18290       {
18291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18292       };
18293     } catch (...) {
18294       {
18295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18296       };
18297     }
18298   }
18299   jresult = result;
18300
18301   //argout typemap for const std::string&
18302
18303   return jresult;
18304 }
18305
18306
18307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18308   int jresult ;
18309   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18310   std::string *arg2 = 0 ;
18311   Dali::Property::Value *arg3 = 0 ;
18312   Dali::Property::AccessMode arg4 ;
18313   Dali::Property::Index result;
18314
18315   arg1 = (Dali::Handle *)jarg1;
18316   if (!jarg2) {
18317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18318     return 0;
18319   }
18320   std::string arg2_str(jarg2);
18321   arg2 = &arg2_str;
18322   arg3 = (Dali::Property::Value *)jarg3;
18323   if (!arg3) {
18324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18325     return 0;
18326   }
18327   arg4 = (Dali::Property::AccessMode)jarg4;
18328   {
18329     try {
18330       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (...) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18342       };
18343     }
18344   }
18345   jresult = result;
18346
18347   //argout typemap for const std::string&
18348
18349   return jresult;
18350 }
18351
18352
18353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18354   void * jresult ;
18355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18356   Dali::Property::Index arg2 ;
18357   Dali::Property::Value result;
18358
18359   arg1 = (Dali::Handle *)jarg1;
18360   arg2 = (Dali::Property::Index)jarg2;
18361   {
18362     try {
18363       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18364     } catch (std::out_of_range& e) {
18365       {
18366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18367       };
18368     } catch (std::exception& e) {
18369       {
18370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18371       };
18372     } catch (...) {
18373       {
18374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18375       };
18376     }
18377   }
18378   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18379   return jresult;
18380 }
18381
18382
18383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18384   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18385   Dali::Property::IndexContainer *arg2 = 0 ;
18386
18387   arg1 = (Dali::Handle *)jarg1;
18388   arg2 = (Dali::Property::IndexContainer *)jarg2;
18389   if (!arg2) {
18390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18391     return ;
18392   }
18393   {
18394     try {
18395       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18396     } catch (std::out_of_range& e) {
18397       {
18398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18399       };
18400     } catch (std::exception& e) {
18401       {
18402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18403       };
18404     } catch (...) {
18405       {
18406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18407       };
18408     }
18409   }
18410 }
18411
18412
18413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18414   void * jresult ;
18415   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18416   Dali::Property::Index arg2 ;
18417   Dali::PropertyCondition *arg3 = 0 ;
18418   Dali::PropertyNotification result;
18419
18420   arg1 = (Dali::Handle *)jarg1;
18421   arg2 = (Dali::Property::Index)jarg2;
18422   arg3 = (Dali::PropertyCondition *)jarg3;
18423   if (!arg3) {
18424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18425     return 0;
18426   }
18427   {
18428     try {
18429       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18430     } catch (std::out_of_range& e) {
18431       {
18432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18433       };
18434     } catch (std::exception& e) {
18435       {
18436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18437       };
18438     } catch (...) {
18439       {
18440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18441       };
18442     }
18443   }
18444   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18445   return jresult;
18446 }
18447
18448
18449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18450   void * jresult ;
18451   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18452   Dali::Property::Index arg2 ;
18453   int arg3 ;
18454   Dali::PropertyCondition *arg4 = 0 ;
18455   Dali::PropertyNotification result;
18456
18457   arg1 = (Dali::Handle *)jarg1;
18458   arg2 = (Dali::Property::Index)jarg2;
18459   arg3 = (int)jarg3;
18460   arg4 = (Dali::PropertyCondition *)jarg4;
18461   if (!arg4) {
18462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18463     return 0;
18464   }
18465   {
18466     try {
18467       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18468     } catch (std::out_of_range& e) {
18469       {
18470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18471       };
18472     } catch (std::exception& e) {
18473       {
18474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18479       };
18480     }
18481   }
18482   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18483   return jresult;
18484 }
18485
18486
18487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18488   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18489   Dali::PropertyNotification arg2 ;
18490   Dali::PropertyNotification *argp2 ;
18491
18492   arg1 = (Dali::Handle *)jarg1;
18493   argp2 = (Dali::PropertyNotification *)jarg2;
18494   if (!argp2) {
18495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18496     return ;
18497   }
18498   arg2 = *argp2;
18499   {
18500     try {
18501       (arg1)->RemovePropertyNotification(arg2);
18502     } catch (std::out_of_range& e) {
18503       {
18504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18505       };
18506     } catch (std::exception& e) {
18507       {
18508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18509       };
18510     } catch (...) {
18511       {
18512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18513       };
18514     }
18515   }
18516 }
18517
18518
18519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18520   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18521
18522   arg1 = (Dali::Handle *)jarg1;
18523   {
18524     try {
18525       (arg1)->RemovePropertyNotifications();
18526     } catch (std::out_of_range& e) {
18527       {
18528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18529       };
18530     } catch (std::exception& e) {
18531       {
18532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18533       };
18534     } catch (...) {
18535       {
18536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18537       };
18538     }
18539   }
18540 }
18541
18542
18543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18544   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18545
18546   arg1 = (Dali::Handle *)jarg1;
18547   {
18548     try {
18549       (arg1)->RemoveConstraints();
18550     } catch (std::out_of_range& e) {
18551       {
18552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18553       };
18554     } catch (std::exception& e) {
18555       {
18556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18557       };
18558     } catch (...) {
18559       {
18560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18561       };
18562     }
18563   }
18564 }
18565
18566
18567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18568   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18569   unsigned int arg2 ;
18570
18571   arg1 = (Dali::Handle *)jarg1;
18572   arg2 = (unsigned int)jarg2;
18573   {
18574     try {
18575       (arg1)->RemoveConstraints(arg2);
18576     } catch (std::out_of_range& e) {
18577       {
18578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18579       };
18580     } catch (std::exception& e) {
18581       {
18582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18583       };
18584     } catch (...) {
18585       {
18586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18587       };
18588     }
18589   }
18590 }
18591
18592
18593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18594   int jresult ;
18595   Dali::Property::Index result;
18596
18597   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18598   jresult = result;
18599   return jresult;
18600 }
18601
18602
18603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18604   void * jresult ;
18605   Dali::Handle result;
18606
18607   {
18608     try {
18609       result = Dali::WeightObject::New();
18610     } catch (std::out_of_range& e) {
18611       {
18612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (std::exception& e) {
18615       {
18616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (...) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18621       };
18622     }
18623   }
18624   jresult = new Dali::Handle((const Dali::Handle &)result);
18625   return jresult;
18626 }
18627
18628
18629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18630   void * jresult ;
18631   Dali::TypeInfo *result = 0 ;
18632
18633   {
18634     try {
18635       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18636     } catch (std::out_of_range& e) {
18637       {
18638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (std::exception& e) {
18641       {
18642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18647       };
18648     }
18649   }
18650   jresult = (void *)result;
18651   return jresult;
18652 }
18653
18654
18655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18656   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18657
18658   arg1 = (Dali::TypeInfo *)jarg1;
18659   {
18660     try {
18661       delete arg1;
18662     } catch (std::out_of_range& e) {
18663       {
18664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18665       };
18666     } catch (std::exception& e) {
18667       {
18668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18669       };
18670     } catch (...) {
18671       {
18672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18673       };
18674     }
18675   }
18676 }
18677
18678
18679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18680   void * jresult ;
18681   Dali::TypeInfo *arg1 = 0 ;
18682   Dali::TypeInfo *result = 0 ;
18683
18684   arg1 = (Dali::TypeInfo *)jarg1;
18685   if (!arg1) {
18686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18687     return 0;
18688   }
18689   {
18690     try {
18691       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18692     } catch (std::out_of_range& e) {
18693       {
18694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18695       };
18696     } catch (std::exception& e) {
18697       {
18698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18699       };
18700     } catch (...) {
18701       {
18702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18703       };
18704     }
18705   }
18706   jresult = (void *)result;
18707   return jresult;
18708 }
18709
18710
18711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18712   void * jresult ;
18713   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18714   Dali::TypeInfo *arg2 = 0 ;
18715   Dali::TypeInfo *result = 0 ;
18716
18717   arg1 = (Dali::TypeInfo *)jarg1;
18718   arg2 = (Dali::TypeInfo *)jarg2;
18719   if (!arg2) {
18720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18721     return 0;
18722   }
18723   {
18724     try {
18725       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18726     } catch (std::out_of_range& e) {
18727       {
18728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18729       };
18730     } catch (std::exception& e) {
18731       {
18732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18733       };
18734     } catch (...) {
18735       {
18736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18737       };
18738     }
18739   }
18740   jresult = (void *)result;
18741   return jresult;
18742 }
18743
18744
18745 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18746   char * jresult ;
18747   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18748   std::string *result = 0 ;
18749
18750   arg1 = (Dali::TypeInfo *)jarg1;
18751   {
18752     try {
18753       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18754     } catch (std::out_of_range& e) {
18755       {
18756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18757       };
18758     } catch (std::exception& e) {
18759       {
18760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (...) {
18763       {
18764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18765       };
18766     }
18767   }
18768   jresult = SWIG_csharp_string_callback(result->c_str());
18769   return jresult;
18770 }
18771
18772
18773 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18774   char * jresult ;
18775   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18776   std::string *result = 0 ;
18777
18778   arg1 = (Dali::TypeInfo *)jarg1;
18779   {
18780     try {
18781       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18782     } catch (std::out_of_range& e) {
18783       {
18784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18785       };
18786     } catch (std::exception& e) {
18787       {
18788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18789       };
18790     } catch (...) {
18791       {
18792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18793       };
18794     }
18795   }
18796   jresult = SWIG_csharp_string_callback(result->c_str());
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18802   void * jresult ;
18803   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18804   Dali::BaseHandle result;
18805
18806   arg1 = (Dali::TypeInfo *)jarg1;
18807   {
18808     try {
18809       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18810     } catch (std::out_of_range& e) {
18811       {
18812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18813       };
18814     } catch (std::exception& e) {
18815       {
18816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (...) {
18819       {
18820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18821       };
18822     }
18823   }
18824   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18825   return jresult;
18826 }
18827
18828
18829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18830   unsigned long jresult ;
18831   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18832   size_t result;
18833
18834   arg1 = (Dali::TypeInfo *)jarg1;
18835   {
18836     try {
18837       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18838     } catch (std::out_of_range& e) {
18839       {
18840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18841       };
18842     } catch (std::exception& e) {
18843       {
18844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18845       };
18846     } catch (...) {
18847       {
18848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18849       };
18850     }
18851   }
18852   jresult = (unsigned long)result;
18853   return jresult;
18854 }
18855
18856
18857 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18858   char * jresult ;
18859   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18860   size_t arg2 ;
18861   std::string result;
18862
18863   arg1 = (Dali::TypeInfo *)jarg1;
18864   arg2 = (size_t)jarg2;
18865   {
18866     try {
18867       result = (arg1)->GetActionName(arg2);
18868     } catch (std::out_of_range& e) {
18869       {
18870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18871       };
18872     } catch (std::exception& e) {
18873       {
18874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18875       };
18876     } catch (...) {
18877       {
18878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18879       };
18880     }
18881   }
18882   jresult = SWIG_csharp_string_callback((&result)->c_str());
18883   return jresult;
18884 }
18885
18886
18887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18888   unsigned long jresult ;
18889   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18890   size_t result;
18891
18892   arg1 = (Dali::TypeInfo *)jarg1;
18893   {
18894     try {
18895       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18896     } catch (std::out_of_range& e) {
18897       {
18898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18899       };
18900     } catch (std::exception& e) {
18901       {
18902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18903       };
18904     } catch (...) {
18905       {
18906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18907       };
18908     }
18909   }
18910   jresult = (unsigned long)result;
18911   return jresult;
18912 }
18913
18914
18915 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18916   char * jresult ;
18917   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18918   size_t arg2 ;
18919   std::string result;
18920
18921   arg1 = (Dali::TypeInfo *)jarg1;
18922   arg2 = (size_t)jarg2;
18923   {
18924     try {
18925       result = (arg1)->GetSignalName(arg2);
18926     } catch (std::out_of_range& e) {
18927       {
18928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18929       };
18930     } catch (std::exception& e) {
18931       {
18932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18933       };
18934     } catch (...) {
18935       {
18936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18937       };
18938     }
18939   }
18940   jresult = SWIG_csharp_string_callback((&result)->c_str());
18941   return jresult;
18942 }
18943
18944
18945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18946   unsigned long jresult ;
18947   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18948   size_t result;
18949
18950   arg1 = (Dali::TypeInfo *)jarg1;
18951   {
18952     try {
18953       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18954     } catch (std::out_of_range& e) {
18955       {
18956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18957       };
18958     } catch (std::exception& e) {
18959       {
18960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18961       };
18962     } catch (...) {
18963       {
18964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18965       };
18966     }
18967   }
18968   jresult = (unsigned long)result;
18969   return jresult;
18970 }
18971
18972
18973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18974   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18975   Dali::Property::IndexContainer *arg2 = 0 ;
18976
18977   arg1 = (Dali::TypeInfo *)jarg1;
18978   arg2 = (Dali::Property::IndexContainer *)jarg2;
18979   if (!arg2) {
18980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18981     return ;
18982   }
18983   {
18984     try {
18985       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18986     } catch (std::out_of_range& e) {
18987       {
18988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18989       };
18990     } catch (std::exception& e) {
18991       {
18992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18993       };
18994     } catch (...) {
18995       {
18996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18997       };
18998     }
18999   }
19000 }
19001
19002
19003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19004   char * jresult ;
19005   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19006   Dali::Property::Index arg2 ;
19007   std::string *result = 0 ;
19008
19009   arg1 = (Dali::TypeInfo *)jarg1;
19010   arg2 = (Dali::Property::Index)jarg2;
19011   {
19012     try {
19013       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19014     } catch (std::out_of_range& e) {
19015       {
19016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19017       };
19018     } catch (std::exception& e) {
19019       {
19020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19021       };
19022     } catch (...) {
19023       {
19024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19025       };
19026     }
19027   }
19028   jresult = SWIG_csharp_string_callback(result->c_str());
19029   return jresult;
19030 }
19031
19032
19033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19034   void * jresult ;
19035   Dali::TypeRegistry result;
19036
19037   {
19038     try {
19039       result = Dali::TypeRegistry::Get();
19040     } catch (std::out_of_range& e) {
19041       {
19042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19043       };
19044     } catch (std::exception& e) {
19045       {
19046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (...) {
19049       {
19050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19051       };
19052     }
19053   }
19054   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19055   return jresult;
19056 }
19057
19058
19059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19060   void * jresult ;
19061   Dali::TypeRegistry *result = 0 ;
19062
19063   {
19064     try {
19065       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19073       };
19074     } catch (...) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19077       };
19078     }
19079   }
19080   jresult = (void *)result;
19081   return jresult;
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19086   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19087
19088   arg1 = (Dali::TypeRegistry *)jarg1;
19089   {
19090     try {
19091       delete arg1;
19092     } catch (std::out_of_range& e) {
19093       {
19094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19095       };
19096     } catch (std::exception& e) {
19097       {
19098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19103       };
19104     }
19105   }
19106 }
19107
19108
19109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19110   void * jresult ;
19111   Dali::TypeRegistry *arg1 = 0 ;
19112   Dali::TypeRegistry *result = 0 ;
19113
19114   arg1 = (Dali::TypeRegistry *)jarg1;
19115   if (!arg1) {
19116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19117     return 0;
19118   }
19119   {
19120     try {
19121       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19122     } catch (std::out_of_range& e) {
19123       {
19124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19125       };
19126     } catch (std::exception& e) {
19127       {
19128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19129       };
19130     } catch (...) {
19131       {
19132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19133       };
19134     }
19135   }
19136   jresult = (void *)result;
19137   return jresult;
19138 }
19139
19140
19141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19142   void * jresult ;
19143   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19144   Dali::TypeRegistry *arg2 = 0 ;
19145   Dali::TypeRegistry *result = 0 ;
19146
19147   arg1 = (Dali::TypeRegistry *)jarg1;
19148   arg2 = (Dali::TypeRegistry *)jarg2;
19149   if (!arg2) {
19150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19151     return 0;
19152   }
19153   {
19154     try {
19155       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19156     } catch (std::out_of_range& e) {
19157       {
19158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19159       };
19160     } catch (std::exception& e) {
19161       {
19162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (...) {
19165       {
19166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19167       };
19168     }
19169   }
19170   jresult = (void *)result;
19171   return jresult;
19172 }
19173
19174
19175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19176   void * jresult ;
19177   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19178   std::string *arg2 = 0 ;
19179   Dali::TypeInfo result;
19180
19181   arg1 = (Dali::TypeRegistry *)jarg1;
19182   if (!jarg2) {
19183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19184     return 0;
19185   }
19186   std::string arg2_str(jarg2);
19187   arg2 = &arg2_str;
19188   {
19189     try {
19190       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (...) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19202       };
19203     }
19204   }
19205   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19206
19207   //argout typemap for const std::string&
19208
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19214   void * jresult ;
19215   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19216   std::type_info *arg2 = 0 ;
19217   Dali::TypeInfo result;
19218
19219   arg1 = (Dali::TypeRegistry *)jarg1;
19220   arg2 = (std::type_info *)jarg2;
19221   if (!arg2) {
19222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19223     return 0;
19224   }
19225   {
19226     try {
19227       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19228     } catch (std::out_of_range& e) {
19229       {
19230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19231       };
19232     } catch (std::exception& e) {
19233       {
19234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (...) {
19237       {
19238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19239       };
19240     }
19241   }
19242   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19243   return jresult;
19244 }
19245
19246
19247 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19248   unsigned long jresult ;
19249   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19250   size_t result;
19251
19252   arg1 = (Dali::TypeRegistry *)jarg1;
19253   {
19254     try {
19255       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19256     } catch (std::out_of_range& e) {
19257       {
19258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (std::exception& e) {
19261       {
19262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (...) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19267       };
19268     }
19269   }
19270   jresult = (unsigned long)result;
19271   return jresult;
19272 }
19273
19274
19275 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19276   char * jresult ;
19277   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19278   size_t arg2 ;
19279   std::string result;
19280
19281   arg1 = (Dali::TypeRegistry *)jarg1;
19282   arg2 = (size_t)jarg2;
19283   {
19284     try {
19285       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19286     } catch (std::out_of_range& e) {
19287       {
19288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19289       };
19290     } catch (std::exception& e) {
19291       {
19292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19293       };
19294     } catch (...) {
19295       {
19296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19297       };
19298     }
19299   }
19300   jresult = SWIG_csharp_string_callback((&result)->c_str());
19301   return jresult;
19302 }
19303
19304
19305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19306   void * jresult ;
19307   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19308   Dali::TypeRegistry *result = 0 ;
19309
19310   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19311   {
19312     try {
19313       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (...) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19325       };
19326     }
19327   }
19328   jresult = (void *)result;
19329   return jresult;
19330 }
19331
19332
19333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19334   void * jresult ;
19335   std::type_info *arg1 = 0 ;
19336   std::type_info *arg2 = 0 ;
19337   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19338   Dali::TypeRegistration *result = 0 ;
19339
19340   arg1 = (std::type_info *)jarg1;
19341   if (!arg1) {
19342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19343     return 0;
19344   }
19345   arg2 = (std::type_info *)jarg2;
19346   if (!arg2) {
19347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19348     return 0;
19349   }
19350   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19351   {
19352     try {
19353       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19354     } catch (std::out_of_range& e) {
19355       {
19356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (std::exception& e) {
19359       {
19360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368   jresult = (void *)result;
19369   return jresult;
19370 }
19371
19372
19373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19374   void * jresult ;
19375   std::type_info *arg1 = 0 ;
19376   std::type_info *arg2 = 0 ;
19377   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19378   bool arg4 ;
19379   Dali::TypeRegistration *result = 0 ;
19380
19381   arg1 = (std::type_info *)jarg1;
19382   if (!arg1) {
19383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19384     return 0;
19385   }
19386   arg2 = (std::type_info *)jarg2;
19387   if (!arg2) {
19388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19389     return 0;
19390   }
19391   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19392   arg4 = jarg4 ? true : false;
19393   {
19394     try {
19395       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (...) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19407       };
19408     }
19409   }
19410   jresult = (void *)result;
19411   return jresult;
19412 }
19413
19414
19415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19416   void * jresult ;
19417   std::string *arg1 = 0 ;
19418   std::type_info *arg2 = 0 ;
19419   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19420   Dali::TypeRegistration *result = 0 ;
19421
19422   if (!jarg1) {
19423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19424     return 0;
19425   }
19426   std::string arg1_str(jarg1);
19427   arg1 = &arg1_str;
19428   arg2 = (std::type_info *)jarg2;
19429   if (!arg2) {
19430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19431     return 0;
19432   }
19433   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19434   {
19435     try {
19436       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19437     } catch (std::out_of_range& e) {
19438       {
19439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19440       };
19441     } catch (std::exception& e) {
19442       {
19443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19444       };
19445     } catch (...) {
19446       {
19447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19448       };
19449     }
19450   }
19451   jresult = (void *)result;
19452
19453   //argout typemap for const std::string&
19454
19455   return jresult;
19456 }
19457
19458
19459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19460   char * jresult ;
19461   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19462   std::string result;
19463
19464   arg1 = (Dali::TypeRegistration *)jarg1;
19465   {
19466     try {
19467       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19468     } catch (std::out_of_range& e) {
19469       {
19470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19471       };
19472     } catch (std::exception& e) {
19473       {
19474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19475       };
19476     } catch (...) {
19477       {
19478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19479       };
19480     }
19481   }
19482   jresult = SWIG_csharp_string_callback((&result)->c_str());
19483   return jresult;
19484 }
19485
19486
19487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19488   std::string *arg1 = 0 ;
19489   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19490
19491   if (!jarg1) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19493     return ;
19494   }
19495   std::string arg1_str(jarg1);
19496   arg1 = &arg1_str;
19497   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19498   {
19499     try {
19500       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19501     } catch (std::out_of_range& e) {
19502       {
19503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19504       };
19505     } catch (std::exception& e) {
19506       {
19507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19508       };
19509     } catch (...) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19512       };
19513     }
19514   }
19515
19516   //argout typemap for const std::string&
19517
19518 }
19519
19520
19521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19522   std::string *arg1 = 0 ;
19523   std::string *arg2 = 0 ;
19524   int arg3 ;
19525   Dali::Property::Type arg4 ;
19526   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19527   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19528
19529   if (!jarg1) {
19530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19531     return ;
19532   }
19533   std::string arg1_str(jarg1);
19534   arg1 = &arg1_str;
19535   if (!jarg2) {
19536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19537     return ;
19538   }
19539   std::string arg2_str(jarg2);
19540   arg2 = &arg2_str;
19541   arg3 = (int)jarg3;
19542   arg4 = (Dali::Property::Type)jarg4;
19543   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19544   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19545   {
19546     try {
19547       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19548     } catch (std::out_of_range& e) {
19549       {
19550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19551       };
19552     } catch (std::exception& e) {
19553       {
19554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19555       };
19556     } catch (...) {
19557       {
19558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19559       };
19560     }
19561   }
19562
19563   //argout typemap for const std::string&
19564
19565
19566   //argout typemap for const std::string&
19567
19568 }
19569
19570
19571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19572   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19573
19574   arg1 = (Dali::TypeRegistration *)jarg1;
19575   {
19576     try {
19577       delete arg1;
19578     } catch (std::out_of_range& e) {
19579       {
19580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19581       };
19582     } catch (std::exception& e) {
19583       {
19584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19585       };
19586     } catch (...) {
19587       {
19588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19589       };
19590     }
19591   }
19592 }
19593
19594
19595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19596   void * jresult ;
19597   Dali::TypeRegistration *arg1 = 0 ;
19598   std::string *arg2 = 0 ;
19599   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19600   Dali::SignalConnectorType *result = 0 ;
19601
19602   arg1 = (Dali::TypeRegistration *)jarg1;
19603   if (!arg1) {
19604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19605     return 0;
19606   }
19607   if (!jarg2) {
19608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19609     return 0;
19610   }
19611   std::string arg2_str(jarg2);
19612   arg2 = &arg2_str;
19613   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19614   {
19615     try {
19616       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19617     } catch (std::out_of_range& e) {
19618       {
19619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19620       };
19621     } catch (std::exception& e) {
19622       {
19623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19624       };
19625     } catch (...) {
19626       {
19627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19628       };
19629     }
19630   }
19631   jresult = (void *)result;
19632
19633   //argout typemap for const std::string&
19634
19635   return jresult;
19636 }
19637
19638
19639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19640   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19641
19642   arg1 = (Dali::SignalConnectorType *)jarg1;
19643   {
19644     try {
19645       delete arg1;
19646     } catch (std::out_of_range& e) {
19647       {
19648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19649       };
19650     } catch (std::exception& e) {
19651       {
19652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19653       };
19654     } catch (...) {
19655       {
19656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19657       };
19658     }
19659   }
19660 }
19661
19662
19663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19664   void * jresult ;
19665   Dali::TypeRegistration *arg1 = 0 ;
19666   std::string *arg2 = 0 ;
19667   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19668   Dali::TypeAction *result = 0 ;
19669
19670   arg1 = (Dali::TypeRegistration *)jarg1;
19671   if (!arg1) {
19672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19673     return 0;
19674   }
19675   if (!jarg2) {
19676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19677     return 0;
19678   }
19679   std::string arg2_str(jarg2);
19680   arg2 = &arg2_str;
19681   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19682   {
19683     try {
19684       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19685     } catch (std::out_of_range& e) {
19686       {
19687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19688       };
19689     } catch (std::exception& e) {
19690       {
19691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19692       };
19693     } catch (...) {
19694       {
19695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19696       };
19697     }
19698   }
19699   jresult = (void *)result;
19700
19701   //argout typemap for const std::string&
19702
19703   return jresult;
19704 }
19705
19706
19707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19708   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19709
19710   arg1 = (Dali::TypeAction *)jarg1;
19711   {
19712     try {
19713       delete arg1;
19714     } catch (std::out_of_range& e) {
19715       {
19716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19717       };
19718     } catch (std::exception& e) {
19719       {
19720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19721       };
19722     } catch (...) {
19723       {
19724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19725       };
19726     }
19727   }
19728 }
19729
19730
19731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19732   void * jresult ;
19733   Dali::TypeRegistration *arg1 = 0 ;
19734   std::string *arg2 = 0 ;
19735   Dali::Property::Index arg3 ;
19736   Dali::Property::Type arg4 ;
19737   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19738   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19739   Dali::PropertyRegistration *result = 0 ;
19740
19741   arg1 = (Dali::TypeRegistration *)jarg1;
19742   if (!arg1) {
19743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19744     return 0;
19745   }
19746   if (!jarg2) {
19747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19748     return 0;
19749   }
19750   std::string arg2_str(jarg2);
19751   arg2 = &arg2_str;
19752   arg3 = (Dali::Property::Index)jarg3;
19753   arg4 = (Dali::Property::Type)jarg4;
19754   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19755   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19756   {
19757     try {
19758       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19759     } catch (std::out_of_range& e) {
19760       {
19761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19762       };
19763     } catch (std::exception& e) {
19764       {
19765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (...) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19770       };
19771     }
19772   }
19773   jresult = (void *)result;
19774
19775   //argout typemap for const std::string&
19776
19777   return jresult;
19778 }
19779
19780
19781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19782   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19783
19784   arg1 = (Dali::PropertyRegistration *)jarg1;
19785   {
19786     try {
19787       delete arg1;
19788     } catch (std::out_of_range& e) {
19789       {
19790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19791       };
19792     } catch (std::exception& e) {
19793       {
19794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19795       };
19796     } catch (...) {
19797       {
19798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19799       };
19800     }
19801   }
19802 }
19803
19804
19805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19806   void * jresult ;
19807   Dali::TypeRegistration *arg1 = 0 ;
19808   std::string *arg2 = 0 ;
19809   Dali::Property::Index arg3 ;
19810   Dali::Property::Type arg4 ;
19811   Dali::AnimatablePropertyRegistration *result = 0 ;
19812
19813   arg1 = (Dali::TypeRegistration *)jarg1;
19814   if (!arg1) {
19815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19816     return 0;
19817   }
19818   if (!jarg2) {
19819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19820     return 0;
19821   }
19822   std::string arg2_str(jarg2);
19823   arg2 = &arg2_str;
19824   arg3 = (Dali::Property::Index)jarg3;
19825   arg4 = (Dali::Property::Type)jarg4;
19826   {
19827     try {
19828       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19829     } catch (std::out_of_range& e) {
19830       {
19831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (std::exception& e) {
19834       {
19835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (...) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19840       };
19841     }
19842   }
19843   jresult = (void *)result;
19844
19845   //argout typemap for const std::string&
19846
19847   return jresult;
19848 }
19849
19850
19851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19852   void * jresult ;
19853   Dali::TypeRegistration *arg1 = 0 ;
19854   std::string *arg2 = 0 ;
19855   Dali::Property::Index arg3 ;
19856   Dali::Property::Value *arg4 = 0 ;
19857   Dali::AnimatablePropertyRegistration *result = 0 ;
19858
19859   arg1 = (Dali::TypeRegistration *)jarg1;
19860   if (!arg1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19862     return 0;
19863   }
19864   if (!jarg2) {
19865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19866     return 0;
19867   }
19868   std::string arg2_str(jarg2);
19869   arg2 = &arg2_str;
19870   arg3 = (Dali::Property::Index)jarg3;
19871   arg4 = (Dali::Property::Value *)jarg4;
19872   if (!arg4) {
19873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19874     return 0;
19875   }
19876   {
19877     try {
19878       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19879     } catch (std::out_of_range& e) {
19880       {
19881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19882       };
19883     } catch (std::exception& e) {
19884       {
19885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19886       };
19887     } catch (...) {
19888       {
19889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19890       };
19891     }
19892   }
19893   jresult = (void *)result;
19894
19895   //argout typemap for const std::string&
19896
19897   return jresult;
19898 }
19899
19900
19901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19902   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19903
19904   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19905   {
19906     try {
19907       delete arg1;
19908     } catch (std::out_of_range& e) {
19909       {
19910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19911       };
19912     } catch (std::exception& e) {
19913       {
19914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19915       };
19916     } catch (...) {
19917       {
19918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19919       };
19920     }
19921   }
19922 }
19923
19924
19925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19926   void * jresult ;
19927   Dali::TypeRegistration *arg1 = 0 ;
19928   std::string *arg2 = 0 ;
19929   Dali::Property::Index arg3 ;
19930   Dali::Property::Index arg4 ;
19931   unsigned int arg5 ;
19932   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19933
19934   arg1 = (Dali::TypeRegistration *)jarg1;
19935   if (!arg1) {
19936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19937     return 0;
19938   }
19939   if (!jarg2) {
19940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19941     return 0;
19942   }
19943   std::string arg2_str(jarg2);
19944   arg2 = &arg2_str;
19945   arg3 = (Dali::Property::Index)jarg3;
19946   arg4 = (Dali::Property::Index)jarg4;
19947   arg5 = (unsigned int)jarg5;
19948   {
19949     try {
19950       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19951     } catch (std::out_of_range& e) {
19952       {
19953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19954       };
19955     } catch (std::exception& e) {
19956       {
19957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19958       };
19959     } catch (...) {
19960       {
19961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19962       };
19963     }
19964   }
19965   jresult = (void *)result;
19966
19967   //argout typemap for const std::string&
19968
19969   return jresult;
19970 }
19971
19972
19973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19974   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19975
19976   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19977   {
19978     try {
19979       delete arg1;
19980     } catch (std::out_of_range& e) {
19981       {
19982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19983       };
19984     } catch (std::exception& e) {
19985       {
19986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19987       };
19988     } catch (...) {
19989       {
19990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19991       };
19992     }
19993   }
19994 }
19995
19996
19997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19998   void * jresult ;
19999   Dali::TypeRegistration *arg1 = 0 ;
20000   std::string *arg2 = 0 ;
20001   Dali::Property::Index arg3 ;
20002   Dali::Property::Type arg4 ;
20003   Dali::ChildPropertyRegistration *result = 0 ;
20004
20005   arg1 = (Dali::TypeRegistration *)jarg1;
20006   if (!arg1) {
20007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20008     return 0;
20009   }
20010   if (!jarg2) {
20011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20012     return 0;
20013   }
20014   std::string arg2_str(jarg2);
20015   arg2 = &arg2_str;
20016   arg3 = (Dali::Property::Index)jarg3;
20017   arg4 = (Dali::Property::Type)jarg4;
20018   {
20019     try {
20020       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20021     } catch (std::out_of_range& e) {
20022       {
20023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20024       };
20025     } catch (std::exception& e) {
20026       {
20027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20028       };
20029     } catch (...) {
20030       {
20031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20032       };
20033     }
20034   }
20035   jresult = (void *)result;
20036
20037   //argout typemap for const std::string&
20038
20039   return jresult;
20040 }
20041
20042
20043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20044   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20045
20046   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20047   {
20048     try {
20049       delete arg1;
20050     } catch (std::out_of_range& e) {
20051       {
20052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20053       };
20054     } catch (std::exception& e) {
20055       {
20056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20057       };
20058     } catch (...) {
20059       {
20060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20061       };
20062     }
20063   }
20064 }
20065
20066
20067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20068   unsigned int jresult ;
20069   std::string *arg1 = 0 ;
20070   std::type_info *arg2 = 0 ;
20071   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20072   bool result;
20073
20074   if (!jarg1) {
20075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20076     return 0;
20077   }
20078   std::string arg1_str(jarg1);
20079   arg1 = &arg1_str;
20080   arg2 = (std::type_info *)jarg2;
20081   if (!arg2) {
20082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20083     return 0;
20084   }
20085   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20086   {
20087     try {
20088       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20089     } catch (std::out_of_range& e) {
20090       {
20091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20092       };
20093     } catch (std::exception& e) {
20094       {
20095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20096       };
20097     } catch (...) {
20098       {
20099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20100       };
20101     }
20102   }
20103   jresult = result;
20104
20105   //argout typemap for const std::string&
20106
20107   return jresult;
20108 }
20109
20110
20111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20112   unsigned int jresult ;
20113   std::string *arg1 = 0 ;
20114   std::string *arg2 = 0 ;
20115   Dali::Property::Index arg3 ;
20116   Dali::Property::Type arg4 ;
20117   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20118   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20119   bool result;
20120
20121   if (!jarg1) {
20122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20123     return 0;
20124   }
20125   std::string arg1_str(jarg1);
20126   arg1 = &arg1_str;
20127   if (!jarg2) {
20128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20129     return 0;
20130   }
20131   std::string arg2_str(jarg2);
20132   arg2 = &arg2_str;
20133   arg3 = (Dali::Property::Index)jarg3;
20134   arg4 = (Dali::Property::Type)jarg4;
20135   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20136   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20137   {
20138     try {
20139       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20140     } catch (std::out_of_range& e) {
20141       {
20142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (std::exception& e) {
20145       {
20146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20147       };
20148     } catch (...) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20151       };
20152     }
20153   }
20154   jresult = result;
20155
20156   //argout typemap for const std::string&
20157
20158
20159   //argout typemap for const std::string&
20160
20161   return jresult;
20162 }
20163
20164
20165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20166   float jresult ;
20167   float result;
20168
20169   result = (float)(float)Dali::ParentOrigin::TOP;
20170   jresult = result;
20171   return jresult;
20172 }
20173
20174
20175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20176   float jresult ;
20177   float result;
20178
20179   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20180   jresult = result;
20181   return jresult;
20182 }
20183
20184
20185 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20186   float jresult ;
20187   float result;
20188
20189   result = (float)(float)Dali::ParentOrigin::LEFT;
20190   jresult = result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20196   float jresult ;
20197   float result;
20198
20199   result = (float)(float)Dali::ParentOrigin::RIGHT;
20200   jresult = result;
20201   return jresult;
20202 }
20203
20204
20205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20206   float jresult ;
20207   float result;
20208
20209   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20210   jresult = result;
20211   return jresult;
20212 }
20213
20214
20215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20216   void * jresult ;
20217   Dali::Vector3 *result = 0 ;
20218
20219   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20220   jresult = (void *)result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20226   void * jresult ;
20227   Dali::Vector3 *result = 0 ;
20228
20229   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20230   jresult = (void *)result;
20231   return jresult;
20232 }
20233
20234
20235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20236   void * jresult ;
20237   Dali::Vector3 *result = 0 ;
20238
20239   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20240   jresult = (void *)result;
20241   return jresult;
20242 }
20243
20244
20245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20246   void * jresult ;
20247   Dali::Vector3 *result = 0 ;
20248
20249   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20250   jresult = (void *)result;
20251   return jresult;
20252 }
20253
20254
20255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20256   void * jresult ;
20257   Dali::Vector3 *result = 0 ;
20258
20259   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20260   jresult = (void *)result;
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20266   void * jresult ;
20267   Dali::Vector3 *result = 0 ;
20268
20269   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20270   jresult = (void *)result;
20271   return jresult;
20272 }
20273
20274
20275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20276   void * jresult ;
20277   Dali::Vector3 *result = 0 ;
20278
20279   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20280   jresult = (void *)result;
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20286   void * jresult ;
20287   Dali::Vector3 *result = 0 ;
20288
20289   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20290   jresult = (void *)result;
20291   return jresult;
20292 }
20293
20294
20295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20296   void * jresult ;
20297   Dali::Vector3 *result = 0 ;
20298
20299   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20300   jresult = (void *)result;
20301   return jresult;
20302 }
20303
20304
20305 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20306   float jresult ;
20307   float result;
20308
20309   result = (float)(float)Dali::AnchorPoint::TOP;
20310   jresult = result;
20311   return jresult;
20312 }
20313
20314
20315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20316   float jresult ;
20317   float result;
20318
20319   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20320   jresult = result;
20321   return jresult;
20322 }
20323
20324
20325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20326   float jresult ;
20327   float result;
20328
20329   result = (float)(float)Dali::AnchorPoint::LEFT;
20330   jresult = result;
20331   return jresult;
20332 }
20333
20334
20335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20336   float jresult ;
20337   float result;
20338
20339   result = (float)(float)Dali::AnchorPoint::RIGHT;
20340   jresult = result;
20341   return jresult;
20342 }
20343
20344
20345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20346   float jresult ;
20347   float result;
20348
20349   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20350   jresult = result;
20351   return jresult;
20352 }
20353
20354
20355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20356   void * jresult ;
20357   Dali::Vector3 *result = 0 ;
20358
20359   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20360   jresult = (void *)result;
20361   return jresult;
20362 }
20363
20364
20365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20366   void * jresult ;
20367   Dali::Vector3 *result = 0 ;
20368
20369   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20370   jresult = (void *)result;
20371   return jresult;
20372 }
20373
20374
20375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20376   void * jresult ;
20377   Dali::Vector3 *result = 0 ;
20378
20379   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20380   jresult = (void *)result;
20381   return jresult;
20382 }
20383
20384
20385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20386   void * jresult ;
20387   Dali::Vector3 *result = 0 ;
20388
20389   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20396   void * jresult ;
20397   Dali::Vector3 *result = 0 ;
20398
20399   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20400   jresult = (void *)result;
20401   return jresult;
20402 }
20403
20404
20405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20406   void * jresult ;
20407   Dali::Vector3 *result = 0 ;
20408
20409   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20410   jresult = (void *)result;
20411   return jresult;
20412 }
20413
20414
20415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20416   void * jresult ;
20417   Dali::Vector3 *result = 0 ;
20418
20419   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20420   jresult = (void *)result;
20421   return jresult;
20422 }
20423
20424
20425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20426   void * jresult ;
20427   Dali::Vector3 *result = 0 ;
20428
20429   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20430   jresult = (void *)result;
20431   return jresult;
20432 }
20433
20434
20435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20436   void * jresult ;
20437   Dali::Vector3 *result = 0 ;
20438
20439   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20440   jresult = (void *)result;
20441   return jresult;
20442 }
20443
20444
20445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20446   void * jresult ;
20447   Dali::Vector4 *result = 0 ;
20448
20449   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20450   jresult = (void *)result;
20451   return jresult;
20452 }
20453
20454
20455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20456   void * jresult ;
20457   Dali::Vector4 *result = 0 ;
20458
20459   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20460   jresult = (void *)result;
20461   return jresult;
20462 }
20463
20464
20465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20466   void * jresult ;
20467   Dali::Vector4 *result = 0 ;
20468
20469   result = (Dali::Vector4 *)&Dali::Color::RED;
20470   jresult = (void *)result;
20471   return jresult;
20472 }
20473
20474
20475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20476   void * jresult ;
20477   Dali::Vector4 *result = 0 ;
20478
20479   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20480   jresult = (void *)result;
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20486   void * jresult ;
20487   Dali::Vector4 *result = 0 ;
20488
20489   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20490   jresult = (void *)result;
20491   return jresult;
20492 }
20493
20494
20495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20496   void * jresult ;
20497   Dali::Vector4 *result = 0 ;
20498
20499   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20500   jresult = (void *)result;
20501   return jresult;
20502 }
20503
20504
20505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20506   void * jresult ;
20507   Dali::Vector4 *result = 0 ;
20508
20509   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20510   jresult = (void *)result;
20511   return jresult;
20512 }
20513
20514
20515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20516   void * jresult ;
20517   Dali::Vector4 *result = 0 ;
20518
20519   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20520   jresult = (void *)result;
20521   return jresult;
20522 }
20523
20524
20525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20526   void * jresult ;
20527   Dali::Vector4 *result = 0 ;
20528
20529   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20530   jresult = (void *)result;
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20536   float jresult ;
20537   float result;
20538
20539   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20540   jresult = result;
20541   return jresult;
20542 }
20543
20544
20545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20546   float jresult ;
20547   float result;
20548
20549   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20550   jresult = result;
20551   return jresult;
20552 }
20553
20554
20555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20556   float jresult ;
20557   float result;
20558
20559   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20560   jresult = result;
20561   return jresult;
20562 }
20563
20564
20565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20566   float jresult ;
20567   float result;
20568
20569   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20570   jresult = result;
20571   return jresult;
20572 }
20573
20574
20575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20576   float jresult ;
20577   float result;
20578
20579   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20580   jresult = result;
20581   return jresult;
20582 }
20583
20584
20585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20586   float jresult ;
20587   float result;
20588
20589   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20590   jresult = result;
20591   return jresult;
20592 }
20593
20594
20595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20596   float jresult ;
20597   float result;
20598
20599   result = (float)(float)Dali::Math::PI;
20600   jresult = result;
20601   return jresult;
20602 }
20603
20604
20605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20606   float jresult ;
20607   float result;
20608
20609   result = (float)(float)Dali::Math::PI_2;
20610   jresult = result;
20611   return jresult;
20612 }
20613
20614
20615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20616   float jresult ;
20617   float result;
20618
20619   result = (float)(float)Dali::Math::PI_4;
20620   jresult = result;
20621   return jresult;
20622 }
20623
20624
20625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20626   float jresult ;
20627   float result;
20628
20629   result = (float)(float)Dali::Math::PI_OVER_180;
20630   jresult = result;
20631   return jresult;
20632 }
20633
20634
20635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20636   float jresult ;
20637   float result;
20638
20639   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20640   jresult = result;
20641   return jresult;
20642 }
20643
20644
20645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20646   int jresult ;
20647   Dali::ResizePolicy::Type result;
20648
20649   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20650   jresult = (int)result;
20651   return jresult;
20652 }
20653
20654
20655 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20656   unsigned long jresult ;
20657   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20658   Dali::VectorBase::SizeType result;
20659
20660   arg1 = (Dali::VectorBase *)jarg1;
20661   {
20662     try {
20663       result = ((Dali::VectorBase const *)arg1)->Count();
20664     } catch (std::out_of_range& e) {
20665       {
20666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20667       };
20668     } catch (std::exception& e) {
20669       {
20670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20671       };
20672     } catch (...) {
20673       {
20674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20675       };
20676     }
20677   }
20678   jresult = (unsigned long)result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20684   unsigned long jresult ;
20685   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20686   Dali::VectorBase::SizeType result;
20687
20688   arg1 = (Dali::VectorBase *)jarg1;
20689   {
20690     try {
20691       result = ((Dali::VectorBase const *)arg1)->Size();
20692     } catch (std::out_of_range& e) {
20693       {
20694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20695       };
20696     } catch (std::exception& e) {
20697       {
20698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20703       };
20704     }
20705   }
20706   jresult = (unsigned long)result;
20707   return jresult;
20708 }
20709
20710
20711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20712   unsigned int jresult ;
20713   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20714   bool result;
20715
20716   arg1 = (Dali::VectorBase *)jarg1;
20717   {
20718     try {
20719       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20720     } catch (std::out_of_range& e) {
20721       {
20722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (std::exception& e) {
20725       {
20726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20727       };
20728     } catch (...) {
20729       {
20730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20731       };
20732     }
20733   }
20734   jresult = result;
20735   return jresult;
20736 }
20737
20738
20739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20740   unsigned long jresult ;
20741   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20742   Dali::VectorBase::SizeType result;
20743
20744   arg1 = (Dali::VectorBase *)jarg1;
20745   {
20746     try {
20747       result = ((Dali::VectorBase const *)arg1)->Capacity();
20748     } catch (std::out_of_range& e) {
20749       {
20750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20751       };
20752     } catch (std::exception& e) {
20753       {
20754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20755       };
20756     } catch (...) {
20757       {
20758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20759       };
20760     }
20761   }
20762   jresult = (unsigned long)result;
20763   return jresult;
20764 }
20765
20766
20767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20768   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20769
20770   arg1 = (Dali::VectorBase *)jarg1;
20771   {
20772     try {
20773       (arg1)->Release();
20774     } catch (std::out_of_range& e) {
20775       {
20776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20777       };
20778     } catch (std::exception& e) {
20779       {
20780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20781       };
20782     } catch (...) {
20783       {
20784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20785       };
20786     }
20787   }
20788 }
20789
20790
20791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20792   void * jresult ;
20793   Dali::Image *result = 0 ;
20794
20795   {
20796     try {
20797       result = (Dali::Image *)new Dali::Image();
20798     } catch (std::out_of_range& e) {
20799       {
20800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20801       };
20802     } catch (std::exception& e) {
20803       {
20804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20805       };
20806     } catch (...) {
20807       {
20808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20809       };
20810     }
20811   }
20812   jresult = (void *)result;
20813   return jresult;
20814 }
20815
20816
20817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20818   Dali::Image *arg1 = (Dali::Image *) 0 ;
20819
20820   arg1 = (Dali::Image *)jarg1;
20821   {
20822     try {
20823       delete arg1;
20824     } catch (std::out_of_range& e) {
20825       {
20826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20827       };
20828     } catch (std::exception& e) {
20829       {
20830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20831       };
20832     } catch (...) {
20833       {
20834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20835       };
20836     }
20837   }
20838 }
20839
20840
20841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20842   void * jresult ;
20843   Dali::Image *arg1 = 0 ;
20844   Dali::Image *result = 0 ;
20845
20846   arg1 = (Dali::Image *)jarg1;
20847   if (!arg1) {
20848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20849     return 0;
20850   }
20851   {
20852     try {
20853       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20854     } catch (std::out_of_range& e) {
20855       {
20856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20857       };
20858     } catch (std::exception& e) {
20859       {
20860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20861       };
20862     } catch (...) {
20863       {
20864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20865       };
20866     }
20867   }
20868   jresult = (void *)result;
20869   return jresult;
20870 }
20871
20872
20873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20874   void * jresult ;
20875   Dali::Image *arg1 = (Dali::Image *) 0 ;
20876   Dali::Image *arg2 = 0 ;
20877   Dali::Image *result = 0 ;
20878
20879   arg1 = (Dali::Image *)jarg1;
20880   arg2 = (Dali::Image *)jarg2;
20881   if (!arg2) {
20882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20883     return 0;
20884   }
20885   {
20886     try {
20887       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20888     } catch (std::out_of_range& e) {
20889       {
20890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20891       };
20892     } catch (std::exception& e) {
20893       {
20894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20895       };
20896     } catch (...) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20899       };
20900     }
20901   }
20902   jresult = (void *)result;
20903   return jresult;
20904 }
20905
20906
20907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20908   void * jresult ;
20909   Dali::BaseHandle arg1 ;
20910   Dali::BaseHandle *argp1 ;
20911   Dali::Image result;
20912
20913   argp1 = (Dali::BaseHandle *)jarg1;
20914   if (!argp1) {
20915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20916     return 0;
20917   }
20918   arg1 = *argp1;
20919   {
20920     try {
20921       result = Dali::Image::DownCast(arg1);
20922     } catch (std::out_of_range& e) {
20923       {
20924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20925       };
20926     } catch (std::exception& e) {
20927       {
20928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20929       };
20930     } catch (...) {
20931       {
20932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20933       };
20934     }
20935   }
20936   jresult = new Dali::Image((const Dali::Image &)result);
20937   return jresult;
20938 }
20939
20940
20941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20942   unsigned int jresult ;
20943   Dali::Image *arg1 = (Dali::Image *) 0 ;
20944   unsigned int result;
20945
20946   arg1 = (Dali::Image *)jarg1;
20947   {
20948     try {
20949       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20950     } catch (std::out_of_range& e) {
20951       {
20952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20953       };
20954     } catch (std::exception& e) {
20955       {
20956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20957       };
20958     } catch (...) {
20959       {
20960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20961       };
20962     }
20963   }
20964   jresult = result;
20965   return jresult;
20966 }
20967
20968
20969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20970   unsigned int jresult ;
20971   Dali::Image *arg1 = (Dali::Image *) 0 ;
20972   unsigned int result;
20973
20974   arg1 = (Dali::Image *)jarg1;
20975   {
20976     try {
20977       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20978     } catch (std::out_of_range& e) {
20979       {
20980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20981       };
20982     } catch (std::exception& e) {
20983       {
20984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20985       };
20986     } catch (...) {
20987       {
20988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20989       };
20990     }
20991   }
20992   jresult = result;
20993   return jresult;
20994 }
20995
20996
20997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20998   void * jresult ;
20999   Dali::Image *arg1 = (Dali::Image *) 0 ;
21000   Dali::Image::ImageSignalType *result = 0 ;
21001
21002   arg1 = (Dali::Image *)jarg1;
21003   {
21004     try {
21005       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21006     } catch (std::out_of_range& e) {
21007       {
21008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21009       };
21010     } catch (std::exception& e) {
21011       {
21012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21013       };
21014     } catch (...) {
21015       {
21016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21017       };
21018     }
21019   }
21020   jresult = (void *)result;
21021   return jresult;
21022 }
21023
21024
21025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21026   int jresult ;
21027   Dali::Pixel::Format result;
21028
21029   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21030   jresult = (int)result;
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21036   int jresult ;
21037   Dali::Pixel::Format result;
21038
21039   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21040   jresult = (int)result;
21041   return jresult;
21042 }
21043
21044
21045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21046   unsigned int jresult ;
21047   Dali::Pixel::Format arg1 ;
21048   bool result;
21049
21050   arg1 = (Dali::Pixel::Format)jarg1;
21051   {
21052     try {
21053       result = (bool)Dali::Pixel::HasAlpha(arg1);
21054     } catch (std::out_of_range& e) {
21055       {
21056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21057       };
21058     } catch (std::exception& e) {
21059       {
21060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21061       };
21062     } catch (...) {
21063       {
21064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21065       };
21066     }
21067   }
21068   jresult = result;
21069   return jresult;
21070 }
21071
21072
21073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21074   unsigned int jresult ;
21075   Dali::Pixel::Format arg1 ;
21076   unsigned int result;
21077
21078   arg1 = (Dali::Pixel::Format)jarg1;
21079   {
21080     try {
21081       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21089       };
21090     } catch (...) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21093       };
21094     }
21095   }
21096   jresult = result;
21097   return jresult;
21098 }
21099
21100
21101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21102   Dali::Pixel::Format arg1 ;
21103   int *arg2 = 0 ;
21104   int *arg3 = 0 ;
21105
21106   arg1 = (Dali::Pixel::Format)jarg1;
21107   arg2 = (int *)jarg2;
21108   if (!arg2) {
21109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21110     return ;
21111   }
21112   arg3 = (int *)jarg3;
21113   if (!arg3) {
21114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21115     return ;
21116   }
21117   {
21118     try {
21119       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21120     } catch (std::out_of_range& e) {
21121       {
21122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21123       };
21124     } catch (std::exception& e) {
21125       {
21126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21127       };
21128     } catch (...) {
21129       {
21130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21131       };
21132     }
21133   }
21134 }
21135
21136
21137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21138   void * jresult ;
21139   unsigned char *arg1 = (unsigned char *) 0 ;
21140   unsigned int arg2 ;
21141   unsigned int arg3 ;
21142   unsigned int arg4 ;
21143   Dali::Pixel::Format arg5 ;
21144   Dali::PixelData::ReleaseFunction arg6 ;
21145   Dali::PixelData result;
21146
21147   arg1 = jarg1;
21148   arg2 = (unsigned int)jarg2;
21149   arg3 = (unsigned int)jarg3;
21150   arg4 = (unsigned int)jarg4;
21151   arg5 = (Dali::Pixel::Format)jarg5;
21152   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21153   {
21154     try {
21155       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21156     } catch (std::out_of_range& e) {
21157       {
21158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21159       };
21160     } catch (std::exception& e) {
21161       {
21162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21163       };
21164     } catch (...) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21167       };
21168     }
21169   }
21170   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21171
21172
21173   return jresult;
21174 }
21175
21176
21177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21178   void * jresult ;
21179   Dali::PixelData *result = 0 ;
21180
21181   {
21182     try {
21183       result = (Dali::PixelData *)new Dali::PixelData();
21184     } catch (std::out_of_range& e) {
21185       {
21186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21187       };
21188     } catch (std::exception& e) {
21189       {
21190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21191       };
21192     } catch (...) {
21193       {
21194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21195       };
21196     }
21197   }
21198   jresult = (void *)result;
21199   return jresult;
21200 }
21201
21202
21203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21204   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21205
21206   arg1 = (Dali::PixelData *)jarg1;
21207   {
21208     try {
21209       delete arg1;
21210     } catch (std::out_of_range& e) {
21211       {
21212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21213       };
21214     } catch (std::exception& e) {
21215       {
21216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (...) {
21219       {
21220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21221       };
21222     }
21223   }
21224 }
21225
21226
21227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21228   void * jresult ;
21229   Dali::PixelData *arg1 = 0 ;
21230   Dali::PixelData *result = 0 ;
21231
21232   arg1 = (Dali::PixelData *)jarg1;
21233   if (!arg1) {
21234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21235     return 0;
21236   }
21237   {
21238     try {
21239       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21240     } catch (std::out_of_range& e) {
21241       {
21242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21243       };
21244     } catch (std::exception& e) {
21245       {
21246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21247       };
21248     } catch (...) {
21249       {
21250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21251       };
21252     }
21253   }
21254   jresult = (void *)result;
21255   return jresult;
21256 }
21257
21258
21259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21260   void * jresult ;
21261   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21262   Dali::PixelData *arg2 = 0 ;
21263   Dali::PixelData *result = 0 ;
21264
21265   arg1 = (Dali::PixelData *)jarg1;
21266   arg2 = (Dali::PixelData *)jarg2;
21267   if (!arg2) {
21268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21269     return 0;
21270   }
21271   {
21272     try {
21273       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21274     } catch (std::out_of_range& e) {
21275       {
21276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21277       };
21278     } catch (std::exception& e) {
21279       {
21280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21281       };
21282     } catch (...) {
21283       {
21284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21285       };
21286     }
21287   }
21288   jresult = (void *)result;
21289   return jresult;
21290 }
21291
21292
21293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21294   unsigned int jresult ;
21295   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21296   unsigned int result;
21297
21298   arg1 = (Dali::PixelData *)jarg1;
21299   {
21300     try {
21301       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21302     } catch (std::out_of_range& e) {
21303       {
21304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21305       };
21306     } catch (std::exception& e) {
21307       {
21308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21309       };
21310     } catch (...) {
21311       {
21312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21313       };
21314     }
21315   }
21316   jresult = result;
21317   return jresult;
21318 }
21319
21320
21321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21322   unsigned int jresult ;
21323   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21324   unsigned int result;
21325
21326   arg1 = (Dali::PixelData *)jarg1;
21327   {
21328     try {
21329       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21330     } catch (std::out_of_range& e) {
21331       {
21332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21333       };
21334     } catch (std::exception& e) {
21335       {
21336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21337       };
21338     } catch (...) {
21339       {
21340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21341       };
21342     }
21343   }
21344   jresult = result;
21345   return jresult;
21346 }
21347
21348
21349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21350   int jresult ;
21351   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21352   Dali::Pixel::Format result;
21353
21354   arg1 = (Dali::PixelData *)jarg1;
21355   {
21356     try {
21357       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21358     } catch (std::out_of_range& e) {
21359       {
21360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21361       };
21362     } catch (std::exception& e) {
21363       {
21364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21365       };
21366     } catch (...) {
21367       {
21368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21369       };
21370     }
21371   }
21372   jresult = (int)result;
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21378   unsigned int jresult ;
21379   unsigned int result;
21380
21381   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21382   jresult = result;
21383   return jresult;
21384 }
21385
21386
21387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21388   unsigned int jresult ;
21389   unsigned int result;
21390
21391   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21392   jresult = result;
21393   return jresult;
21394 }
21395
21396
21397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21398   unsigned int jresult ;
21399   unsigned int result;
21400
21401   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21402   jresult = result;
21403   return jresult;
21404 }
21405
21406
21407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21408   unsigned int jresult ;
21409   unsigned int result;
21410
21411   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21412   jresult = result;
21413   return jresult;
21414 }
21415
21416
21417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21418   unsigned int jresult ;
21419   unsigned int result;
21420
21421   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21422   jresult = result;
21423   return jresult;
21424 }
21425
21426
21427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21428   unsigned int jresult ;
21429   unsigned int result;
21430
21431   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21432   jresult = result;
21433   return jresult;
21434 }
21435
21436
21437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21438   void * jresult ;
21439   Dali::TextureType::Type arg1 ;
21440   Dali::Pixel::Format arg2 ;
21441   unsigned int arg3 ;
21442   unsigned int arg4 ;
21443   Dali::Texture result;
21444
21445   arg1 = (Dali::TextureType::Type)jarg1;
21446   arg2 = (Dali::Pixel::Format)jarg2;
21447   arg3 = (unsigned int)jarg3;
21448   arg4 = (unsigned int)jarg4;
21449   {
21450     try {
21451       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21452     } catch (std::out_of_range& e) {
21453       {
21454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21455       };
21456     } catch (std::exception& e) {
21457       {
21458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21459       };
21460     } catch (...) {
21461       {
21462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21463       };
21464     }
21465   }
21466   jresult = new Dali::Texture((const Dali::Texture &)result);
21467   return jresult;
21468 }
21469
21470
21471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21472   void * jresult ;
21473   NativeImageInterface *arg1 = 0 ;
21474   Dali::Texture result;
21475
21476   arg1 = (NativeImageInterface *)jarg1;
21477   if (!arg1) {
21478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21479     return 0;
21480   }
21481   {
21482     try {
21483       result = Dali::Texture::New(*arg1);
21484     } catch (std::out_of_range& e) {
21485       {
21486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21487       };
21488     } catch (std::exception& e) {
21489       {
21490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (...) {
21493       {
21494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21495       };
21496     }
21497   }
21498   jresult = new Dali::Texture((const Dali::Texture &)result);
21499   return jresult;
21500 }
21501
21502
21503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21504   void * jresult ;
21505   Dali::Texture *result = 0 ;
21506
21507   {
21508     try {
21509       result = (Dali::Texture *)new Dali::Texture();
21510     } catch (std::out_of_range& e) {
21511       {
21512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21513       };
21514     } catch (std::exception& e) {
21515       {
21516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21517       };
21518     } catch (...) {
21519       {
21520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21521       };
21522     }
21523   }
21524   jresult = (void *)result;
21525   return jresult;
21526 }
21527
21528
21529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21530   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21531
21532   arg1 = (Dali::Texture *)jarg1;
21533   {
21534     try {
21535       delete arg1;
21536     } catch (std::out_of_range& e) {
21537       {
21538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21539       };
21540     } catch (std::exception& e) {
21541       {
21542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21543       };
21544     } catch (...) {
21545       {
21546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21547       };
21548     }
21549   }
21550 }
21551
21552
21553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21554   void * jresult ;
21555   Dali::Texture *arg1 = 0 ;
21556   Dali::Texture *result = 0 ;
21557
21558   arg1 = (Dali::Texture *)jarg1;
21559   if (!arg1) {
21560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21561     return 0;
21562   }
21563   {
21564     try {
21565       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21566     } catch (std::out_of_range& e) {
21567       {
21568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21569       };
21570     } catch (std::exception& e) {
21571       {
21572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21573       };
21574     } catch (...) {
21575       {
21576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21577       };
21578     }
21579   }
21580   jresult = (void *)result;
21581   return jresult;
21582 }
21583
21584
21585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21586   void * jresult ;
21587   Dali::BaseHandle arg1 ;
21588   Dali::BaseHandle *argp1 ;
21589   Dali::Texture result;
21590
21591   argp1 = (Dali::BaseHandle *)jarg1;
21592   if (!argp1) {
21593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21594     return 0;
21595   }
21596   arg1 = *argp1;
21597   {
21598     try {
21599       result = Dali::Texture::DownCast(arg1);
21600     } catch (std::out_of_range& e) {
21601       {
21602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21603       };
21604     } catch (std::exception& e) {
21605       {
21606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21607       };
21608     } catch (...) {
21609       {
21610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21611       };
21612     }
21613   }
21614   jresult = new Dali::Texture((const Dali::Texture &)result);
21615   return jresult;
21616 }
21617
21618
21619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21620   void * jresult ;
21621   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21622   Dali::Texture *arg2 = 0 ;
21623   Dali::Texture *result = 0 ;
21624
21625   arg1 = (Dali::Texture *)jarg1;
21626   arg2 = (Dali::Texture *)jarg2;
21627   if (!arg2) {
21628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21629     return 0;
21630   }
21631   {
21632     try {
21633       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21634     } catch (std::out_of_range& e) {
21635       {
21636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21637       };
21638     } catch (std::exception& e) {
21639       {
21640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21641       };
21642     } catch (...) {
21643       {
21644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21645       };
21646     }
21647   }
21648   jresult = (void *)result;
21649   return jresult;
21650 }
21651
21652
21653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21654   unsigned int jresult ;
21655   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21656   Dali::PixelData arg2 ;
21657   Dali::PixelData *argp2 ;
21658   bool result;
21659
21660   arg1 = (Dali::Texture *)jarg1;
21661   argp2 = (Dali::PixelData *)jarg2;
21662   if (!argp2) {
21663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21664     return 0;
21665   }
21666   arg2 = *argp2;
21667   {
21668     try {
21669       result = (bool)(arg1)->Upload(arg2);
21670     } catch (std::out_of_range& e) {
21671       {
21672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21673       };
21674     } catch (std::exception& e) {
21675       {
21676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21677       };
21678     } catch (...) {
21679       {
21680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21681       };
21682     }
21683   }
21684   jresult = result;
21685   return jresult;
21686 }
21687
21688
21689 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) {
21690   unsigned int jresult ;
21691   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21692   Dali::PixelData arg2 ;
21693   unsigned int arg3 ;
21694   unsigned int arg4 ;
21695   unsigned int arg5 ;
21696   unsigned int arg6 ;
21697   unsigned int arg7 ;
21698   unsigned int arg8 ;
21699   Dali::PixelData *argp2 ;
21700   bool result;
21701
21702   arg1 = (Dali::Texture *)jarg1;
21703   argp2 = (Dali::PixelData *)jarg2;
21704   if (!argp2) {
21705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21706     return 0;
21707   }
21708   arg2 = *argp2;
21709   arg3 = (unsigned int)jarg3;
21710   arg4 = (unsigned int)jarg4;
21711   arg5 = (unsigned int)jarg5;
21712   arg6 = (unsigned int)jarg6;
21713   arg7 = (unsigned int)jarg7;
21714   arg8 = (unsigned int)jarg8;
21715   {
21716     try {
21717       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21718     } catch (std::out_of_range& e) {
21719       {
21720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21721       };
21722     } catch (std::exception& e) {
21723       {
21724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21725       };
21726     } catch (...) {
21727       {
21728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21729       };
21730     }
21731   }
21732   jresult = result;
21733   return jresult;
21734 }
21735
21736
21737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21738   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21739
21740   arg1 = (Dali::Texture *)jarg1;
21741   {
21742     try {
21743       (arg1)->GenerateMipmaps();
21744     } catch (std::out_of_range& e) {
21745       {
21746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21747       };
21748     } catch (std::exception& e) {
21749       {
21750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21751       };
21752     } catch (...) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21755       };
21756     }
21757   }
21758 }
21759
21760
21761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21762   unsigned int jresult ;
21763   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21764   unsigned int result;
21765
21766   arg1 = (Dali::Texture *)jarg1;
21767   {
21768     try {
21769       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21770     } catch (std::out_of_range& e) {
21771       {
21772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21773       };
21774     } catch (std::exception& e) {
21775       {
21776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (...) {
21779       {
21780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21781       };
21782     }
21783   }
21784   jresult = result;
21785   return jresult;
21786 }
21787
21788
21789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21790   unsigned int jresult ;
21791   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21792   unsigned int result;
21793
21794   arg1 = (Dali::Texture *)jarg1;
21795   {
21796     try {
21797       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21798     } catch (std::out_of_range& e) {
21799       {
21800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21801       };
21802     } catch (std::exception& e) {
21803       {
21804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21805       };
21806     } catch (...) {
21807       {
21808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21809       };
21810     }
21811   }
21812   jresult = result;
21813   return jresult;
21814 }
21815
21816
21817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21818   void * jresult ;
21819   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21820   Dali::Texture *result = 0 ;
21821
21822   arg1 = (Dali::Internal::Texture *)jarg1;
21823   {
21824     try {
21825       result = (Dali::Texture *)new Dali::Texture(arg1);
21826     } catch (std::out_of_range& e) {
21827       {
21828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21829       };
21830     } catch (std::exception& e) {
21831       {
21832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (...) {
21835       {
21836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21837       };
21838     }
21839   }
21840   jresult = (void *)result;
21841   return jresult;
21842 }
21843
21844
21845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21846   void * jresult ;
21847   Dali::Sampler result;
21848
21849   {
21850     try {
21851       result = Dali::Sampler::New();
21852     } catch (std::out_of_range& e) {
21853       {
21854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21855       };
21856     } catch (std::exception& e) {
21857       {
21858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (...) {
21861       {
21862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21863       };
21864     }
21865   }
21866   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21867   return jresult;
21868 }
21869
21870
21871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21872   void * jresult ;
21873   Dali::Sampler *result = 0 ;
21874
21875   {
21876     try {
21877       result = (Dali::Sampler *)new Dali::Sampler();
21878     } catch (std::out_of_range& e) {
21879       {
21880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (std::exception& e) {
21883       {
21884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21885       };
21886     } catch (...) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21889       };
21890     }
21891   }
21892   jresult = (void *)result;
21893   return jresult;
21894 }
21895
21896
21897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21898   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21899
21900   arg1 = (Dali::Sampler *)jarg1;
21901   {
21902     try {
21903       delete arg1;
21904     } catch (std::out_of_range& e) {
21905       {
21906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21907       };
21908     } catch (std::exception& e) {
21909       {
21910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21911       };
21912     } catch (...) {
21913       {
21914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21915       };
21916     }
21917   }
21918 }
21919
21920
21921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21922   void * jresult ;
21923   Dali::Sampler *arg1 = 0 ;
21924   Dali::Sampler *result = 0 ;
21925
21926   arg1 = (Dali::Sampler *)jarg1;
21927   if (!arg1) {
21928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21929     return 0;
21930   }
21931   {
21932     try {
21933       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21934     } catch (std::out_of_range& e) {
21935       {
21936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21937       };
21938     } catch (std::exception& e) {
21939       {
21940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21941       };
21942     } catch (...) {
21943       {
21944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21945       };
21946     }
21947   }
21948   jresult = (void *)result;
21949   return jresult;
21950 }
21951
21952
21953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21954   void * jresult ;
21955   Dali::BaseHandle arg1 ;
21956   Dali::BaseHandle *argp1 ;
21957   Dali::Sampler result;
21958
21959   argp1 = (Dali::BaseHandle *)jarg1;
21960   if (!argp1) {
21961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21962     return 0;
21963   }
21964   arg1 = *argp1;
21965   {
21966     try {
21967       result = Dali::Sampler::DownCast(arg1);
21968     } catch (std::out_of_range& e) {
21969       {
21970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21971       };
21972     } catch (std::exception& e) {
21973       {
21974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21975       };
21976     } catch (...) {
21977       {
21978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21979       };
21980     }
21981   }
21982   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21983   return jresult;
21984 }
21985
21986
21987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21988   void * jresult ;
21989   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21990   Dali::Sampler *arg2 = 0 ;
21991   Dali::Sampler *result = 0 ;
21992
21993   arg1 = (Dali::Sampler *)jarg1;
21994   arg2 = (Dali::Sampler *)jarg2;
21995   if (!arg2) {
21996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21997     return 0;
21998   }
21999   {
22000     try {
22001       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22002     } catch (std::out_of_range& e) {
22003       {
22004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22005       };
22006     } catch (std::exception& e) {
22007       {
22008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22009       };
22010     } catch (...) {
22011       {
22012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22013       };
22014     }
22015   }
22016   jresult = (void *)result;
22017   return jresult;
22018 }
22019
22020
22021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22022   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22023   Dali::FilterMode::Type arg2 ;
22024   Dali::FilterMode::Type arg3 ;
22025
22026   arg1 = (Dali::Sampler *)jarg1;
22027   arg2 = (Dali::FilterMode::Type)jarg2;
22028   arg3 = (Dali::FilterMode::Type)jarg3;
22029   {
22030     try {
22031       (arg1)->SetFilterMode(arg2,arg3);
22032     } catch (std::out_of_range& e) {
22033       {
22034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22035       };
22036     } catch (std::exception& e) {
22037       {
22038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22039       };
22040     } catch (...) {
22041       {
22042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22043       };
22044     }
22045   }
22046 }
22047
22048
22049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22050   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22051   Dali::WrapMode::Type arg2 ;
22052   Dali::WrapMode::Type arg3 ;
22053
22054   arg1 = (Dali::Sampler *)jarg1;
22055   arg2 = (Dali::WrapMode::Type)jarg2;
22056   arg3 = (Dali::WrapMode::Type)jarg3;
22057   {
22058     try {
22059       (arg1)->SetWrapMode(arg2,arg3);
22060     } catch (std::out_of_range& e) {
22061       {
22062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22063       };
22064     } catch (std::exception& e) {
22065       {
22066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22067       };
22068     } catch (...) {
22069       {
22070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22071       };
22072     }
22073   }
22074 }
22075
22076
22077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22078   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22079   Dali::WrapMode::Type arg2 ;
22080   Dali::WrapMode::Type arg3 ;
22081   Dali::WrapMode::Type arg4 ;
22082
22083   arg1 = (Dali::Sampler *)jarg1;
22084   arg2 = (Dali::WrapMode::Type)jarg2;
22085   arg3 = (Dali::WrapMode::Type)jarg3;
22086   arg4 = (Dali::WrapMode::Type)jarg4;
22087   {
22088     try {
22089       (arg1)->SetWrapMode(arg2,arg3,arg4);
22090     } catch (std::out_of_range& e) {
22091       {
22092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22093       };
22094     } catch (std::exception& e) {
22095       {
22096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22097       };
22098     } catch (...) {
22099       {
22100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22101       };
22102     }
22103   }
22104 }
22105
22106
22107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22108   void * jresult ;
22109   Dali::TextureSet result;
22110
22111   {
22112     try {
22113       result = Dali::TextureSet::New();
22114     } catch (std::out_of_range& e) {
22115       {
22116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (std::exception& e) {
22119       {
22120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (...) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22125       };
22126     }
22127   }
22128   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22134   void * jresult ;
22135   Dali::TextureSet *result = 0 ;
22136
22137   {
22138     try {
22139       result = (Dali::TextureSet *)new Dali::TextureSet();
22140     } catch (std::out_of_range& e) {
22141       {
22142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22143       };
22144     } catch (std::exception& e) {
22145       {
22146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22147       };
22148     } catch (...) {
22149       {
22150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22151       };
22152     }
22153   }
22154   jresult = (void *)result;
22155   return jresult;
22156 }
22157
22158
22159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22160   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22161
22162   arg1 = (Dali::TextureSet *)jarg1;
22163   {
22164     try {
22165       delete arg1;
22166     } catch (std::out_of_range& e) {
22167       {
22168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22169       };
22170     } catch (std::exception& e) {
22171       {
22172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22173       };
22174     } catch (...) {
22175       {
22176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22177       };
22178     }
22179   }
22180 }
22181
22182
22183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22184   void * jresult ;
22185   Dali::TextureSet *arg1 = 0 ;
22186   Dali::TextureSet *result = 0 ;
22187
22188   arg1 = (Dali::TextureSet *)jarg1;
22189   if (!arg1) {
22190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22191     return 0;
22192   }
22193   {
22194     try {
22195       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22196     } catch (std::out_of_range& e) {
22197       {
22198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22199       };
22200     } catch (std::exception& e) {
22201       {
22202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22203       };
22204     } catch (...) {
22205       {
22206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22207       };
22208     }
22209   }
22210   jresult = (void *)result;
22211   return jresult;
22212 }
22213
22214
22215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22216   void * jresult ;
22217   Dali::BaseHandle arg1 ;
22218   Dali::BaseHandle *argp1 ;
22219   Dali::TextureSet result;
22220
22221   argp1 = (Dali::BaseHandle *)jarg1;
22222   if (!argp1) {
22223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22224     return 0;
22225   }
22226   arg1 = *argp1;
22227   {
22228     try {
22229       result = Dali::TextureSet::DownCast(arg1);
22230     } catch (std::out_of_range& e) {
22231       {
22232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22233       };
22234     } catch (std::exception& e) {
22235       {
22236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22237       };
22238     } catch (...) {
22239       {
22240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22241       };
22242     }
22243   }
22244   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22245   return jresult;
22246 }
22247
22248
22249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22250   void * jresult ;
22251   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22252   Dali::TextureSet *arg2 = 0 ;
22253   Dali::TextureSet *result = 0 ;
22254
22255   arg1 = (Dali::TextureSet *)jarg1;
22256   arg2 = (Dali::TextureSet *)jarg2;
22257   if (!arg2) {
22258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22259     return 0;
22260   }
22261   {
22262     try {
22263       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22264     } catch (std::out_of_range& e) {
22265       {
22266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22267       };
22268     } catch (std::exception& e) {
22269       {
22270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22275       };
22276     }
22277   }
22278   jresult = (void *)result;
22279   return jresult;
22280 }
22281
22282
22283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22284   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22285   size_t arg2 ;
22286   Dali::Texture arg3 ;
22287   Dali::Texture *argp3 ;
22288
22289   arg1 = (Dali::TextureSet *)jarg1;
22290   arg2 = (size_t)jarg2;
22291   argp3 = (Dali::Texture *)jarg3;
22292   if (!argp3) {
22293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22294     return ;
22295   }
22296   arg3 = *argp3;
22297   {
22298     try {
22299       (arg1)->SetTexture(arg2,arg3);
22300     } catch (std::out_of_range& e) {
22301       {
22302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22303       };
22304     } catch (std::exception& e) {
22305       {
22306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22307       };
22308     } catch (...) {
22309       {
22310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22311       };
22312     }
22313   }
22314 }
22315
22316
22317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22318   void * jresult ;
22319   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22320   size_t arg2 ;
22321   Dali::Texture result;
22322
22323   arg1 = (Dali::TextureSet *)jarg1;
22324   arg2 = (size_t)jarg2;
22325   {
22326     try {
22327       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22328     } catch (std::out_of_range& e) {
22329       {
22330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22331       };
22332     } catch (std::exception& e) {
22333       {
22334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22335       };
22336     } catch (...) {
22337       {
22338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22339       };
22340     }
22341   }
22342   jresult = new Dali::Texture((const Dali::Texture &)result);
22343   return jresult;
22344 }
22345
22346
22347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22348   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22349   size_t arg2 ;
22350   Dali::Sampler arg3 ;
22351   Dali::Sampler *argp3 ;
22352
22353   arg1 = (Dali::TextureSet *)jarg1;
22354   arg2 = (size_t)jarg2;
22355   argp3 = (Dali::Sampler *)jarg3;
22356   if (!argp3) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22358     return ;
22359   }
22360   arg3 = *argp3;
22361   {
22362     try {
22363       (arg1)->SetSampler(arg2,arg3);
22364     } catch (std::out_of_range& e) {
22365       {
22366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22367       };
22368     } catch (std::exception& e) {
22369       {
22370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22371       };
22372     } catch (...) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22375       };
22376     }
22377   }
22378 }
22379
22380
22381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22382   void * jresult ;
22383   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22384   size_t arg2 ;
22385   Dali::Sampler result;
22386
22387   arg1 = (Dali::TextureSet *)jarg1;
22388   arg2 = (size_t)jarg2;
22389   {
22390     try {
22391       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22392     } catch (std::out_of_range& e) {
22393       {
22394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22395       };
22396     } catch (std::exception& e) {
22397       {
22398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22399       };
22400     } catch (...) {
22401       {
22402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22403       };
22404     }
22405   }
22406   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22407   return jresult;
22408 }
22409
22410
22411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22412   unsigned long jresult ;
22413   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22414   size_t result;
22415
22416   arg1 = (Dali::TextureSet *)jarg1;
22417   {
22418     try {
22419       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22427       };
22428     } catch (...) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22431       };
22432     }
22433   }
22434   jresult = (unsigned long)result;
22435   return jresult;
22436 }
22437
22438
22439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22440   void * jresult ;
22441   Dali::Property::Map *arg1 = 0 ;
22442   Dali::PropertyBuffer result;
22443
22444   arg1 = (Dali::Property::Map *)jarg1;
22445   if (!arg1) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22447     return 0;
22448   }
22449   {
22450     try {
22451       result = Dali::PropertyBuffer::New(*arg1);
22452     } catch (std::out_of_range& e) {
22453       {
22454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (std::exception& e) {
22457       {
22458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22467   return jresult;
22468 }
22469
22470
22471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22472   void * jresult ;
22473   Dali::PropertyBuffer *result = 0 ;
22474
22475   {
22476     try {
22477       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22478     } catch (std::out_of_range& e) {
22479       {
22480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22481       };
22482     } catch (std::exception& e) {
22483       {
22484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22485       };
22486     } catch (...) {
22487       {
22488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22489       };
22490     }
22491   }
22492   jresult = (void *)result;
22493   return jresult;
22494 }
22495
22496
22497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22498   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22499
22500   arg1 = (Dali::PropertyBuffer *)jarg1;
22501   {
22502     try {
22503       delete arg1;
22504     } catch (std::out_of_range& e) {
22505       {
22506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22507       };
22508     } catch (std::exception& e) {
22509       {
22510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22511       };
22512     } catch (...) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22515       };
22516     }
22517   }
22518 }
22519
22520
22521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22522   void * jresult ;
22523   Dali::PropertyBuffer *arg1 = 0 ;
22524   Dali::PropertyBuffer *result = 0 ;
22525
22526   arg1 = (Dali::PropertyBuffer *)jarg1;
22527   if (!arg1) {
22528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22529     return 0;
22530   }
22531   {
22532     try {
22533       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22534     } catch (std::out_of_range& e) {
22535       {
22536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22537       };
22538     } catch (std::exception& e) {
22539       {
22540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22541       };
22542     } catch (...) {
22543       {
22544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22545       };
22546     }
22547   }
22548   jresult = (void *)result;
22549   return jresult;
22550 }
22551
22552
22553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22554   void * jresult ;
22555   Dali::BaseHandle arg1 ;
22556   Dali::BaseHandle *argp1 ;
22557   Dali::PropertyBuffer result;
22558
22559   argp1 = (Dali::BaseHandle *)jarg1;
22560   if (!argp1) {
22561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22562     return 0;
22563   }
22564   arg1 = *argp1;
22565   {
22566     try {
22567       result = Dali::PropertyBuffer::DownCast(arg1);
22568     } catch (std::out_of_range& e) {
22569       {
22570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22571       };
22572     } catch (std::exception& e) {
22573       {
22574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22575       };
22576     } catch (...) {
22577       {
22578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22579       };
22580     }
22581   }
22582   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22583   return jresult;
22584 }
22585
22586
22587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22588   void * jresult ;
22589   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22590   Dali::PropertyBuffer *arg2 = 0 ;
22591   Dali::PropertyBuffer *result = 0 ;
22592
22593   arg1 = (Dali::PropertyBuffer *)jarg1;
22594   arg2 = (Dali::PropertyBuffer *)jarg2;
22595   if (!arg2) {
22596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22597     return 0;
22598   }
22599   {
22600     try {
22601       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (...) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22613       };
22614     }
22615   }
22616   jresult = (void *)result;
22617   return jresult;
22618 }
22619
22620
22621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22622   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22623   void *arg2 = (void *) 0 ;
22624   std::size_t arg3 ;
22625
22626   arg1 = (Dali::PropertyBuffer *)jarg1;
22627   arg2 = jarg2;
22628   arg3 = (std::size_t)jarg3;
22629   {
22630     try {
22631       (arg1)->SetData((void const *)arg2,arg3);
22632     } catch (std::out_of_range& e) {
22633       {
22634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22635       };
22636     } catch (std::exception& e) {
22637       {
22638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22639       };
22640     } catch (...) {
22641       {
22642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22643       };
22644     }
22645   }
22646 }
22647
22648
22649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22650   unsigned long jresult ;
22651   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22652   std::size_t result;
22653
22654   arg1 = (Dali::PropertyBuffer *)jarg1;
22655   {
22656     try {
22657       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22658     } catch (std::out_of_range& e) {
22659       {
22660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22661       };
22662     } catch (std::exception& e) {
22663       {
22664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22665       };
22666     } catch (...) {
22667       {
22668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22669       };
22670     }
22671   }
22672   jresult = (unsigned long)result;
22673   return jresult;
22674 }
22675
22676
22677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22678   void * jresult ;
22679   Dali::Geometry result;
22680
22681   {
22682     try {
22683       result = Dali::Geometry::New();
22684     } catch (std::out_of_range& e) {
22685       {
22686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22687       };
22688     } catch (std::exception& e) {
22689       {
22690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (...) {
22693       {
22694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22695       };
22696     }
22697   }
22698   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22699   return jresult;
22700 }
22701
22702
22703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22704   void * jresult ;
22705   Dali::Geometry *result = 0 ;
22706
22707   {
22708     try {
22709       result = (Dali::Geometry *)new Dali::Geometry();
22710     } catch (std::out_of_range& e) {
22711       {
22712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22713       };
22714     } catch (std::exception& e) {
22715       {
22716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22717       };
22718     } catch (...) {
22719       {
22720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22721       };
22722     }
22723   }
22724   jresult = (void *)result;
22725   return jresult;
22726 }
22727
22728
22729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22730   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22731
22732   arg1 = (Dali::Geometry *)jarg1;
22733   {
22734     try {
22735       delete arg1;
22736     } catch (std::out_of_range& e) {
22737       {
22738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22739       };
22740     } catch (std::exception& e) {
22741       {
22742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22743       };
22744     } catch (...) {
22745       {
22746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22747       };
22748     }
22749   }
22750 }
22751
22752
22753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22754   void * jresult ;
22755   Dali::Geometry *arg1 = 0 ;
22756   Dali::Geometry *result = 0 ;
22757
22758   arg1 = (Dali::Geometry *)jarg1;
22759   if (!arg1) {
22760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22761     return 0;
22762   }
22763   {
22764     try {
22765       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22766     } catch (std::out_of_range& e) {
22767       {
22768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22769       };
22770     } catch (std::exception& e) {
22771       {
22772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22773       };
22774     } catch (...) {
22775       {
22776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22777       };
22778     }
22779   }
22780   jresult = (void *)result;
22781   return jresult;
22782 }
22783
22784
22785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22786   void * jresult ;
22787   Dali::BaseHandle arg1 ;
22788   Dali::BaseHandle *argp1 ;
22789   Dali::Geometry result;
22790
22791   argp1 = (Dali::BaseHandle *)jarg1;
22792   if (!argp1) {
22793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22794     return 0;
22795   }
22796   arg1 = *argp1;
22797   {
22798     try {
22799       result = Dali::Geometry::DownCast(arg1);
22800     } catch (std::out_of_range& e) {
22801       {
22802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22803       };
22804     } catch (std::exception& e) {
22805       {
22806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22807       };
22808     } catch (...) {
22809       {
22810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22811       };
22812     }
22813   }
22814   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22815   return jresult;
22816 }
22817
22818
22819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22820   void * jresult ;
22821   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22822   Dali::Geometry *arg2 = 0 ;
22823   Dali::Geometry *result = 0 ;
22824
22825   arg1 = (Dali::Geometry *)jarg1;
22826   arg2 = (Dali::Geometry *)jarg2;
22827   if (!arg2) {
22828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22829     return 0;
22830   }
22831   {
22832     try {
22833       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22834     } catch (std::out_of_range& e) {
22835       {
22836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22837       };
22838     } catch (std::exception& e) {
22839       {
22840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22841       };
22842     } catch (...) {
22843       {
22844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22845       };
22846     }
22847   }
22848   jresult = (void *)result;
22849   return jresult;
22850 }
22851
22852
22853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22854   unsigned long jresult ;
22855   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22856   Dali::PropertyBuffer *arg2 = 0 ;
22857   std::size_t result;
22858
22859   arg1 = (Dali::Geometry *)jarg1;
22860   arg2 = (Dali::PropertyBuffer *)jarg2;
22861   if (!arg2) {
22862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22863     return 0;
22864   }
22865   {
22866     try {
22867       result = (arg1)->AddVertexBuffer(*arg2);
22868     } catch (std::out_of_range& e) {
22869       {
22870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22871       };
22872     } catch (std::exception& e) {
22873       {
22874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22875       };
22876     } catch (...) {
22877       {
22878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22879       };
22880     }
22881   }
22882   jresult = (unsigned long)result;
22883   return jresult;
22884 }
22885
22886
22887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22888   unsigned long jresult ;
22889   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22890   std::size_t result;
22891
22892   arg1 = (Dali::Geometry *)jarg1;
22893   {
22894     try {
22895       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22896     } catch (std::out_of_range& e) {
22897       {
22898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22899       };
22900     } catch (std::exception& e) {
22901       {
22902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22903       };
22904     } catch (...) {
22905       {
22906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22907       };
22908     }
22909   }
22910   jresult = (unsigned long)result;
22911   return jresult;
22912 }
22913
22914
22915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22916   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22917   std::size_t arg2 ;
22918
22919   arg1 = (Dali::Geometry *)jarg1;
22920   arg2 = (std::size_t)jarg2;
22921   {
22922     try {
22923       (arg1)->RemoveVertexBuffer(arg2);
22924     } catch (std::out_of_range& e) {
22925       {
22926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22927       };
22928     } catch (std::exception& e) {
22929       {
22930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22931       };
22932     } catch (...) {
22933       {
22934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22935       };
22936     }
22937   }
22938 }
22939
22940
22941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22942   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22943   unsigned short *arg2 = (unsigned short *) 0 ;
22944   size_t arg3 ;
22945
22946   arg1 = (Dali::Geometry *)jarg1;
22947   arg2 = jarg2;
22948   arg3 = (size_t)jarg3;
22949   {
22950     try {
22951       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22952     } catch (std::out_of_range& e) {
22953       {
22954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22955       };
22956     } catch (std::exception& e) {
22957       {
22958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22959       };
22960     } catch (...) {
22961       {
22962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22963       };
22964     }
22965   }
22966
22967
22968 }
22969
22970
22971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22972   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22973   Dali::Geometry::Type arg2 ;
22974
22975   arg1 = (Dali::Geometry *)jarg1;
22976   arg2 = (Dali::Geometry::Type)jarg2;
22977   {
22978     try {
22979       (arg1)->SetType(arg2);
22980     } catch (std::out_of_range& e) {
22981       {
22982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22983       };
22984     } catch (std::exception& e) {
22985       {
22986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22987       };
22988     } catch (...) {
22989       {
22990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22991       };
22992     }
22993   }
22994 }
22995
22996
22997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22998   int jresult ;
22999   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
23000   Dali::Geometry::Type result;
23001
23002   arg1 = (Dali::Geometry *)jarg1;
23003   {
23004     try {
23005       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23006     } catch (std::out_of_range& e) {
23007       {
23008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23009       };
23010     } catch (std::exception& e) {
23011       {
23012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23013       };
23014     } catch (...) {
23015       {
23016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23017       };
23018     }
23019   }
23020   jresult = (int)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23026   void * jresult ;
23027   Dali::Shader::Hint *result = 0 ;
23028
23029   {
23030     try {
23031       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23032     } catch (std::out_of_range& e) {
23033       {
23034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23035       };
23036     } catch (std::exception& e) {
23037       {
23038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23039       };
23040     } catch (...) {
23041       {
23042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23043       };
23044     }
23045   }
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23052   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23053
23054   arg1 = (Dali::Shader::Hint *)jarg1;
23055   {
23056     try {
23057       delete arg1;
23058     } catch (std::out_of_range& e) {
23059       {
23060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23061       };
23062     } catch (std::exception& e) {
23063       {
23064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23065       };
23066     } catch (...) {
23067       {
23068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23069       };
23070     }
23071   }
23072 }
23073
23074
23075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23076   int jresult ;
23077   int result;
23078
23079   result = (int)Dali::Shader::Property::PROGRAM;
23080   jresult = (int)result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23086   void * jresult ;
23087   Dali::Shader::Property *result = 0 ;
23088
23089   {
23090     try {
23091       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23092     } catch (std::out_of_range& e) {
23093       {
23094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23095       };
23096     } catch (std::exception& e) {
23097       {
23098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23099       };
23100     } catch (...) {
23101       {
23102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23103       };
23104     }
23105   }
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23112   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23113
23114   arg1 = (Dali::Shader::Property *)jarg1;
23115   {
23116     try {
23117       delete arg1;
23118     } catch (std::out_of_range& e) {
23119       {
23120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23121       };
23122     } catch (std::exception& e) {
23123       {
23124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23125       };
23126     } catch (...) {
23127       {
23128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23129       };
23130     }
23131   }
23132 }
23133
23134
23135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23136   void * jresult ;
23137   std::string *arg1 = 0 ;
23138   std::string *arg2 = 0 ;
23139   Dali::Shader::Hint::Value arg3 ;
23140   Dali::Shader result;
23141
23142   if (!jarg1) {
23143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23144     return 0;
23145   }
23146   std::string arg1_str(jarg1);
23147   arg1 = &arg1_str;
23148   if (!jarg2) {
23149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23150     return 0;
23151   }
23152   std::string arg2_str(jarg2);
23153   arg2 = &arg2_str;
23154   arg3 = (Dali::Shader::Hint::Value)jarg3;
23155   {
23156     try {
23157       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23158     } catch (std::out_of_range& e) {
23159       {
23160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23161       };
23162     } catch (std::exception& e) {
23163       {
23164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23165       };
23166     } catch (...) {
23167       {
23168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23169       };
23170     }
23171   }
23172   jresult = new Dali::Shader((const Dali::Shader &)result);
23173
23174   //argout typemap for const std::string&
23175
23176
23177   //argout typemap for const std::string&
23178
23179   return jresult;
23180 }
23181
23182
23183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23184   void * jresult ;
23185   std::string *arg1 = 0 ;
23186   std::string *arg2 = 0 ;
23187   Dali::Shader result;
23188
23189   if (!jarg1) {
23190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23191     return 0;
23192   }
23193   std::string arg1_str(jarg1);
23194   arg1 = &arg1_str;
23195   if (!jarg2) {
23196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23197     return 0;
23198   }
23199   std::string arg2_str(jarg2);
23200   arg2 = &arg2_str;
23201   {
23202     try {
23203       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23204     } catch (std::out_of_range& e) {
23205       {
23206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23207       };
23208     } catch (std::exception& e) {
23209       {
23210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23211       };
23212     } catch (...) {
23213       {
23214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23215       };
23216     }
23217   }
23218   jresult = new Dali::Shader((const Dali::Shader &)result);
23219
23220   //argout typemap for const std::string&
23221
23222
23223   //argout typemap for const std::string&
23224
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23230   void * jresult ;
23231   Dali::Shader *result = 0 ;
23232
23233   {
23234     try {
23235       result = (Dali::Shader *)new Dali::Shader();
23236     } catch (std::out_of_range& e) {
23237       {
23238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23239       };
23240     } catch (std::exception& e) {
23241       {
23242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23243       };
23244     } catch (...) {
23245       {
23246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23247       };
23248     }
23249   }
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23256   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23257
23258   arg1 = (Dali::Shader *)jarg1;
23259   {
23260     try {
23261       delete arg1;
23262     } catch (std::out_of_range& e) {
23263       {
23264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23265       };
23266     } catch (std::exception& e) {
23267       {
23268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23269       };
23270     } catch (...) {
23271       {
23272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23273       };
23274     }
23275   }
23276 }
23277
23278
23279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23280   void * jresult ;
23281   Dali::Shader *arg1 = 0 ;
23282   Dali::Shader *result = 0 ;
23283
23284   arg1 = (Dali::Shader *)jarg1;
23285   if (!arg1) {
23286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23287     return 0;
23288   }
23289   {
23290     try {
23291       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23292     } catch (std::out_of_range& e) {
23293       {
23294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23295       };
23296     } catch (std::exception& e) {
23297       {
23298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23299       };
23300     } catch (...) {
23301       {
23302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23303       };
23304     }
23305   }
23306   jresult = (void *)result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23312   void * jresult ;
23313   Dali::BaseHandle arg1 ;
23314   Dali::BaseHandle *argp1 ;
23315   Dali::Shader result;
23316
23317   argp1 = (Dali::BaseHandle *)jarg1;
23318   if (!argp1) {
23319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23320     return 0;
23321   }
23322   arg1 = *argp1;
23323   {
23324     try {
23325       result = Dali::Shader::DownCast(arg1);
23326     } catch (std::out_of_range& e) {
23327       {
23328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23329       };
23330     } catch (std::exception& e) {
23331       {
23332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23333       };
23334     } catch (...) {
23335       {
23336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23337       };
23338     }
23339   }
23340   jresult = new Dali::Shader((const Dali::Shader &)result);
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23346   void * jresult ;
23347   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23348   Dali::Shader *arg2 = 0 ;
23349   Dali::Shader *result = 0 ;
23350
23351   arg1 = (Dali::Shader *)jarg1;
23352   arg2 = (Dali::Shader *)jarg2;
23353   if (!arg2) {
23354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23355     return 0;
23356   }
23357   {
23358     try {
23359       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23360     } catch (std::out_of_range& e) {
23361       {
23362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23363       };
23364     } catch (std::exception& e) {
23365       {
23366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23367       };
23368     } catch (...) {
23369       {
23370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23371       };
23372     }
23373   }
23374   jresult = (void *)result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23380   int jresult ;
23381   int result;
23382
23383   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23384   jresult = (int)result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23390   int jresult ;
23391   int result;
23392
23393   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23400   int jresult ;
23401   int result;
23402
23403   result = (int)Dali::Renderer::Property::BLEND_MODE;
23404   jresult = (int)result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23410   int jresult ;
23411   int result;
23412
23413   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23420   int jresult ;
23421   int result;
23422
23423   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23424   jresult = (int)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23430   int jresult ;
23431   int result;
23432
23433   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23434   jresult = (int)result;
23435   return jresult;
23436 }
23437
23438
23439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23440   int jresult ;
23441   int result;
23442
23443   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23444   jresult = (int)result;
23445   return jresult;
23446 }
23447
23448
23449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23450   int jresult ;
23451   int result;
23452
23453   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23454   jresult = (int)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23460   int jresult ;
23461   int result;
23462
23463   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23464   jresult = (int)result;
23465   return jresult;
23466 }
23467
23468
23469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23470   int jresult ;
23471   int result;
23472
23473   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23474   jresult = (int)result;
23475   return jresult;
23476 }
23477
23478
23479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23480   int jresult ;
23481   int result;
23482
23483   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23484   jresult = (int)result;
23485   return jresult;
23486 }
23487
23488
23489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23490   int jresult ;
23491   int result;
23492
23493   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23494   jresult = (int)result;
23495   return jresult;
23496 }
23497
23498
23499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23500   int jresult ;
23501   int result;
23502
23503   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23504   jresult = (int)result;
23505   return jresult;
23506 }
23507
23508
23509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23510   int jresult ;
23511   int result;
23512
23513   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23514   jresult = (int)result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23520   int jresult ;
23521   int result;
23522
23523   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23524   jresult = (int)result;
23525   return jresult;
23526 }
23527
23528
23529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23530   int jresult ;
23531   int result;
23532
23533   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23534   jresult = (int)result;
23535   return jresult;
23536 }
23537
23538
23539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23540   int jresult ;
23541   int result;
23542
23543   result = (int)Dali::Renderer::Property::RENDER_MODE;
23544   jresult = (int)result;
23545   return jresult;
23546 }
23547
23548
23549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23550   int jresult ;
23551   int result;
23552
23553   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23554   jresult = (int)result;
23555   return jresult;
23556 }
23557
23558
23559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23560   int jresult ;
23561   int result;
23562
23563   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23564   jresult = (int)result;
23565   return jresult;
23566 }
23567
23568
23569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23570   int jresult ;
23571   int result;
23572
23573   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23574   jresult = (int)result;
23575   return jresult;
23576 }
23577
23578
23579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23580   int jresult ;
23581   int result;
23582
23583   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23584   jresult = (int)result;
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23590   int jresult ;
23591   int result;
23592
23593   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23594   jresult = (int)result;
23595   return jresult;
23596 }
23597
23598
23599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23600   int jresult ;
23601   int result;
23602
23603   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23604   jresult = (int)result;
23605   return jresult;
23606 }
23607
23608
23609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23610   int jresult ;
23611   int result;
23612
23613   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23614   jresult = (int)result;
23615   return jresult;
23616 }
23617
23618
23619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23620   void * jresult ;
23621   Dali::Renderer::Property *result = 0 ;
23622
23623   {
23624     try {
23625       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23626     } catch (std::out_of_range& e) {
23627       {
23628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23629       };
23630     } catch (std::exception& e) {
23631       {
23632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23633       };
23634     } catch (...) {
23635       {
23636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23637       };
23638     }
23639   }
23640   jresult = (void *)result;
23641   return jresult;
23642 }
23643
23644
23645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23646   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23647
23648   arg1 = (Dali::Renderer::Property *)jarg1;
23649   {
23650     try {
23651       delete arg1;
23652     } catch (std::out_of_range& e) {
23653       {
23654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23655       };
23656     } catch (std::exception& e) {
23657       {
23658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23659       };
23660     } catch (...) {
23661       {
23662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23663       };
23664     }
23665   }
23666 }
23667
23668
23669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23670   void * jresult ;
23671   Dali::Geometry *arg1 = 0 ;
23672   Dali::Shader *arg2 = 0 ;
23673   Dali::Renderer result;
23674
23675   arg1 = (Dali::Geometry *)jarg1;
23676   if (!arg1) {
23677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23678     return 0;
23679   }
23680   arg2 = (Dali::Shader *)jarg2;
23681   if (!arg2) {
23682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23683     return 0;
23684   }
23685   {
23686     try {
23687       result = Dali::Renderer::New(*arg1,*arg2);
23688     } catch (std::out_of_range& e) {
23689       {
23690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23691       };
23692     } catch (std::exception& e) {
23693       {
23694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23695       };
23696     } catch (...) {
23697       {
23698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23699       };
23700     }
23701   }
23702   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23703   return jresult;
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23708   void * jresult ;
23709   Dali::Renderer *result = 0 ;
23710
23711   {
23712     try {
23713       result = (Dali::Renderer *)new Dali::Renderer();
23714     } catch (std::out_of_range& e) {
23715       {
23716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23717       };
23718     } catch (std::exception& e) {
23719       {
23720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23725       };
23726     }
23727   }
23728   jresult = (void *)result;
23729   return jresult;
23730 }
23731
23732
23733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23734   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23735
23736   arg1 = (Dali::Renderer *)jarg1;
23737   {
23738     try {
23739       delete arg1;
23740     } catch (std::out_of_range& e) {
23741       {
23742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23743       };
23744     } catch (std::exception& e) {
23745       {
23746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23747       };
23748     } catch (...) {
23749       {
23750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23751       };
23752     }
23753   }
23754 }
23755
23756
23757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23758   void * jresult ;
23759   Dali::Renderer *arg1 = 0 ;
23760   Dali::Renderer *result = 0 ;
23761
23762   arg1 = (Dali::Renderer *)jarg1;
23763   if (!arg1) {
23764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23765     return 0;
23766   }
23767   {
23768     try {
23769       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23770     } catch (std::out_of_range& e) {
23771       {
23772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23773       };
23774     } catch (std::exception& e) {
23775       {
23776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23777       };
23778     } catch (...) {
23779       {
23780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23781       };
23782     }
23783   }
23784   jresult = (void *)result;
23785   return jresult;
23786 }
23787
23788
23789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23790   void * jresult ;
23791   Dali::BaseHandle arg1 ;
23792   Dali::BaseHandle *argp1 ;
23793   Dali::Renderer result;
23794
23795   argp1 = (Dali::BaseHandle *)jarg1;
23796   if (!argp1) {
23797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23798     return 0;
23799   }
23800   arg1 = *argp1;
23801   {
23802     try {
23803       result = Dali::Renderer::DownCast(arg1);
23804     } catch (std::out_of_range& e) {
23805       {
23806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23807       };
23808     } catch (std::exception& e) {
23809       {
23810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23811       };
23812     } catch (...) {
23813       {
23814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23815       };
23816     }
23817   }
23818   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23819   return jresult;
23820 }
23821
23822
23823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23824   void * jresult ;
23825   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23826   Dali::Renderer *arg2 = 0 ;
23827   Dali::Renderer *result = 0 ;
23828
23829   arg1 = (Dali::Renderer *)jarg1;
23830   arg2 = (Dali::Renderer *)jarg2;
23831   if (!arg2) {
23832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23833     return 0;
23834   }
23835   {
23836     try {
23837       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23838     } catch (std::out_of_range& e) {
23839       {
23840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23841       };
23842     } catch (std::exception& e) {
23843       {
23844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23845       };
23846     } catch (...) {
23847       {
23848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23849       };
23850     }
23851   }
23852   jresult = (void *)result;
23853   return jresult;
23854 }
23855
23856
23857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23858   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23859   Dali::Geometry *arg2 = 0 ;
23860
23861   arg1 = (Dali::Renderer *)jarg1;
23862   arg2 = (Dali::Geometry *)jarg2;
23863   if (!arg2) {
23864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23865     return ;
23866   }
23867   {
23868     try {
23869       (arg1)->SetGeometry(*arg2);
23870     } catch (std::out_of_range& e) {
23871       {
23872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23873       };
23874     } catch (std::exception& e) {
23875       {
23876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23877       };
23878     } catch (...) {
23879       {
23880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23881       };
23882     }
23883   }
23884 }
23885
23886
23887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23888   void * jresult ;
23889   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23890   Dali::Geometry result;
23891
23892   arg1 = (Dali::Renderer *)jarg1;
23893   {
23894     try {
23895       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23896     } catch (std::out_of_range& e) {
23897       {
23898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (std::exception& e) {
23901       {
23902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (...) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23907       };
23908     }
23909   }
23910   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23911   return jresult;
23912 }
23913
23914
23915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23916   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23917   int arg2 ;
23918   int arg3 ;
23919
23920   arg1 = (Dali::Renderer *)jarg1;
23921   arg2 = (int)jarg2;
23922   arg3 = (int)jarg3;
23923   {
23924     try {
23925       (arg1)->SetIndexRange(arg2,arg3);
23926     } catch (std::out_of_range& e) {
23927       {
23928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23929       };
23930     } catch (std::exception& e) {
23931       {
23932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23933       };
23934     } catch (...) {
23935       {
23936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23937       };
23938     }
23939   }
23940 }
23941
23942
23943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23944   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23945   Dali::TextureSet *arg2 = 0 ;
23946
23947   arg1 = (Dali::Renderer *)jarg1;
23948   arg2 = (Dali::TextureSet *)jarg2;
23949   if (!arg2) {
23950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23951     return ;
23952   }
23953   {
23954     try {
23955       (arg1)->SetTextures(*arg2);
23956     } catch (std::out_of_range& e) {
23957       {
23958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23959       };
23960     } catch (std::exception& e) {
23961       {
23962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23963       };
23964     } catch (...) {
23965       {
23966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23967       };
23968     }
23969   }
23970 }
23971
23972
23973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23974   void * jresult ;
23975   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23976   Dali::TextureSet result;
23977
23978   arg1 = (Dali::Renderer *)jarg1;
23979   {
23980     try {
23981       result = ((Dali::Renderer const *)arg1)->GetTextures();
23982     } catch (std::out_of_range& e) {
23983       {
23984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23985       };
23986     } catch (std::exception& e) {
23987       {
23988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23989       };
23990     } catch (...) {
23991       {
23992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23993       };
23994     }
23995   }
23996   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23997   return jresult;
23998 }
23999
24000
24001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24002   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24003   Dali::Shader *arg2 = 0 ;
24004
24005   arg1 = (Dali::Renderer *)jarg1;
24006   arg2 = (Dali::Shader *)jarg2;
24007   if (!arg2) {
24008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24009     return ;
24010   }
24011   {
24012     try {
24013       (arg1)->SetShader(*arg2);
24014     } catch (std::out_of_range& e) {
24015       {
24016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24017       };
24018     } catch (std::exception& e) {
24019       {
24020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24021       };
24022     } catch (...) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24025       };
24026     }
24027   }
24028 }
24029
24030
24031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24032   void * jresult ;
24033   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24034   Dali::Shader result;
24035
24036   arg1 = (Dali::Renderer *)jarg1;
24037   {
24038     try {
24039       result = ((Dali::Renderer const *)arg1)->GetShader();
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (...) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24051       };
24052     }
24053   }
24054   jresult = new Dali::Shader((const Dali::Shader &)result);
24055   return jresult;
24056 }
24057
24058
24059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24060   void * jresult ;
24061   Dali::FrameBuffer::Attachment *result = 0 ;
24062
24063   {
24064     try {
24065       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24066     } catch (std::out_of_range& e) {
24067       {
24068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (std::exception& e) {
24071       {
24072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24073       };
24074     } catch (...) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24077       };
24078     }
24079   }
24080   jresult = (void *)result;
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24086   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24087
24088   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24089   {
24090     try {
24091       delete arg1;
24092     } catch (std::out_of_range& e) {
24093       {
24094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24095       };
24096     } catch (std::exception& e) {
24097       {
24098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24099       };
24100     } catch (...) {
24101       {
24102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24103       };
24104     }
24105   }
24106 }
24107
24108
24109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24110   void * jresult ;
24111   unsigned int arg1 ;
24112   unsigned int arg2 ;
24113   unsigned int arg3 ;
24114   Dali::FrameBuffer result;
24115
24116   arg1 = (unsigned int)jarg1;
24117   arg2 = (unsigned int)jarg2;
24118   arg3 = (unsigned int)jarg3;
24119   {
24120     try {
24121       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24142   void * jresult ;
24143   Dali::FrameBuffer *result = 0 ;
24144
24145   {
24146     try {
24147       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24148     } catch (std::out_of_range& e) {
24149       {
24150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24151       };
24152     } catch (std::exception& e) {
24153       {
24154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (...) {
24157       {
24158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24159       };
24160     }
24161   }
24162   jresult = (void *)result;
24163   return jresult;
24164 }
24165
24166
24167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24168   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24169
24170   arg1 = (Dali::FrameBuffer *)jarg1;
24171   {
24172     try {
24173       delete arg1;
24174     } catch (std::out_of_range& e) {
24175       {
24176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24177       };
24178     } catch (std::exception& e) {
24179       {
24180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24181       };
24182     } catch (...) {
24183       {
24184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24185       };
24186     }
24187   }
24188 }
24189
24190
24191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24192   void * jresult ;
24193   Dali::FrameBuffer *arg1 = 0 ;
24194   Dali::FrameBuffer *result = 0 ;
24195
24196   arg1 = (Dali::FrameBuffer *)jarg1;
24197   if (!arg1) {
24198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24199     return 0;
24200   }
24201   {
24202     try {
24203       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24204     } catch (std::out_of_range& e) {
24205       {
24206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24207       };
24208     } catch (std::exception& e) {
24209       {
24210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24211       };
24212     } catch (...) {
24213       {
24214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24215       };
24216     }
24217   }
24218   jresult = (void *)result;
24219   return jresult;
24220 }
24221
24222
24223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24224   void * jresult ;
24225   Dali::BaseHandle arg1 ;
24226   Dali::BaseHandle *argp1 ;
24227   Dali::FrameBuffer result;
24228
24229   argp1 = (Dali::BaseHandle *)jarg1;
24230   if (!argp1) {
24231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24232     return 0;
24233   }
24234   arg1 = *argp1;
24235   {
24236     try {
24237       result = Dali::FrameBuffer::DownCast(arg1);
24238     } catch (std::out_of_range& e) {
24239       {
24240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24241       };
24242     } catch (std::exception& e) {
24243       {
24244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24245       };
24246     } catch (...) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24249       };
24250     }
24251   }
24252   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24253   return jresult;
24254 }
24255
24256
24257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24258   void * jresult ;
24259   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24260   Dali::FrameBuffer *arg2 = 0 ;
24261   Dali::FrameBuffer *result = 0 ;
24262
24263   arg1 = (Dali::FrameBuffer *)jarg1;
24264   arg2 = (Dali::FrameBuffer *)jarg2;
24265   if (!arg2) {
24266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24267     return 0;
24268   }
24269   {
24270     try {
24271       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24272     } catch (std::out_of_range& e) {
24273       {
24274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24275       };
24276     } catch (std::exception& e) {
24277       {
24278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24279       };
24280     } catch (...) {
24281       {
24282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24283       };
24284     }
24285   }
24286   jresult = (void *)result;
24287   return jresult;
24288 }
24289
24290
24291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24292   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24293   Dali::Texture *arg2 = 0 ;
24294
24295   arg1 = (Dali::FrameBuffer *)jarg1;
24296   arg2 = (Dali::Texture *)jarg2;
24297   if (!arg2) {
24298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24299     return ;
24300   }
24301   {
24302     try {
24303       (arg1)->AttachColorTexture(*arg2);
24304     } catch (std::out_of_range& e) {
24305       {
24306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24307       };
24308     } catch (std::exception& e) {
24309       {
24310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24311       };
24312     } catch (...) {
24313       {
24314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24315       };
24316     }
24317   }
24318 }
24319
24320
24321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24322   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24323   Dali::Texture *arg2 = 0 ;
24324   unsigned int arg3 ;
24325   unsigned int arg4 ;
24326
24327   arg1 = (Dali::FrameBuffer *)jarg1;
24328   arg2 = (Dali::Texture *)jarg2;
24329   if (!arg2) {
24330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24331     return ;
24332   }
24333   arg3 = (unsigned int)jarg3;
24334   arg4 = (unsigned int)jarg4;
24335   {
24336     try {
24337       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24338     } catch (std::out_of_range& e) {
24339       {
24340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24341       };
24342     } catch (std::exception& e) {
24343       {
24344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24345       };
24346     } catch (...) {
24347       {
24348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24349       };
24350     }
24351   }
24352 }
24353
24354
24355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24356   void * jresult ;
24357   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24358   Dali::Texture result;
24359
24360   arg1 = (Dali::FrameBuffer *)jarg1;
24361   {
24362     try {
24363       result = (arg1)->GetColorTexture();
24364     } catch (std::out_of_range& e) {
24365       {
24366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24367       };
24368     } catch (std::exception& e) {
24369       {
24370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24371       };
24372     } catch (...) {
24373       {
24374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24375       };
24376     }
24377   }
24378   jresult = new Dali::Texture((const Dali::Texture &)result);
24379   return jresult;
24380 }
24381
24382
24383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24384   void * jresult ;
24385   Dali::RenderTaskList *result = 0 ;
24386
24387   {
24388     try {
24389       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24390     } catch (std::out_of_range& e) {
24391       {
24392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (std::exception& e) {
24395       {
24396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24397       };
24398     } catch (...) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24401       };
24402     }
24403   }
24404   jresult = (void *)result;
24405   return jresult;
24406 }
24407
24408
24409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24410   void * jresult ;
24411   Dali::BaseHandle arg1 ;
24412   Dali::BaseHandle *argp1 ;
24413   Dali::RenderTaskList result;
24414
24415   argp1 = (Dali::BaseHandle *)jarg1;
24416   if (!argp1) {
24417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24418     return 0;
24419   }
24420   arg1 = *argp1;
24421   {
24422     try {
24423       result = Dali::RenderTaskList::DownCast(arg1);
24424     } catch (std::out_of_range& e) {
24425       {
24426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24427       };
24428     } catch (std::exception& e) {
24429       {
24430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24431       };
24432     } catch (...) {
24433       {
24434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24435       };
24436     }
24437   }
24438   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24439   return jresult;
24440 }
24441
24442
24443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24444   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24445
24446   arg1 = (Dali::RenderTaskList *)jarg1;
24447   {
24448     try {
24449       delete arg1;
24450     } catch (std::out_of_range& e) {
24451       {
24452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24453       };
24454     } catch (std::exception& e) {
24455       {
24456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24457       };
24458     } catch (...) {
24459       {
24460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24461       };
24462     }
24463   }
24464 }
24465
24466
24467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24468   void * jresult ;
24469   Dali::RenderTaskList *arg1 = 0 ;
24470   Dali::RenderTaskList *result = 0 ;
24471
24472   arg1 = (Dali::RenderTaskList *)jarg1;
24473   if (!arg1) {
24474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24475     return 0;
24476   }
24477   {
24478     try {
24479       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24480     } catch (std::out_of_range& e) {
24481       {
24482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24483       };
24484     } catch (std::exception& e) {
24485       {
24486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24487       };
24488     } catch (...) {
24489       {
24490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24491       };
24492     }
24493   }
24494   jresult = (void *)result;
24495   return jresult;
24496 }
24497
24498
24499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24500   void * jresult ;
24501   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24502   Dali::RenderTaskList *arg2 = 0 ;
24503   Dali::RenderTaskList *result = 0 ;
24504
24505   arg1 = (Dali::RenderTaskList *)jarg1;
24506   arg2 = (Dali::RenderTaskList *)jarg2;
24507   if (!arg2) {
24508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24509     return 0;
24510   }
24511   {
24512     try {
24513       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24514     } catch (std::out_of_range& e) {
24515       {
24516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24517       };
24518     } catch (std::exception& e) {
24519       {
24520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24521       };
24522     } catch (...) {
24523       {
24524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24525       };
24526     }
24527   }
24528   jresult = (void *)result;
24529   return jresult;
24530 }
24531
24532
24533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24534   void * jresult ;
24535   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24536   Dali::RenderTask result;
24537
24538   arg1 = (Dali::RenderTaskList *)jarg1;
24539   {
24540     try {
24541       result = (arg1)->CreateTask();
24542     } catch (std::out_of_range& e) {
24543       {
24544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24545       };
24546     } catch (std::exception& e) {
24547       {
24548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24549       };
24550     } catch (...) {
24551       {
24552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24553       };
24554     }
24555   }
24556   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24557   return jresult;
24558 }
24559
24560
24561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24562   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24563   Dali::RenderTask arg2 ;
24564   Dali::RenderTask *argp2 ;
24565
24566   arg1 = (Dali::RenderTaskList *)jarg1;
24567   argp2 = (Dali::RenderTask *)jarg2;
24568   if (!argp2) {
24569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24570     return ;
24571   }
24572   arg2 = *argp2;
24573   {
24574     try {
24575       (arg1)->RemoveTask(arg2);
24576     } catch (std::out_of_range& e) {
24577       {
24578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24579       };
24580     } catch (std::exception& e) {
24581       {
24582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24583       };
24584     } catch (...) {
24585       {
24586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24587       };
24588     }
24589   }
24590 }
24591
24592
24593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24594   unsigned int jresult ;
24595   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24596   unsigned int result;
24597
24598   arg1 = (Dali::RenderTaskList *)jarg1;
24599   {
24600     try {
24601       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24602     } catch (std::out_of_range& e) {
24603       {
24604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24605       };
24606     } catch (std::exception& e) {
24607       {
24608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24609       };
24610     } catch (...) {
24611       {
24612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24613       };
24614     }
24615   }
24616   jresult = result;
24617   return jresult;
24618 }
24619
24620
24621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24622   void * jresult ;
24623   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24624   unsigned int arg2 ;
24625   Dali::RenderTask result;
24626
24627   arg1 = (Dali::RenderTaskList *)jarg1;
24628   arg2 = (unsigned int)jarg2;
24629   {
24630     try {
24631       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24632     } catch (std::out_of_range& e) {
24633       {
24634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24635       };
24636     } catch (std::exception& e) {
24637       {
24638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24639       };
24640     } catch (...) {
24641       {
24642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24643       };
24644     }
24645   }
24646   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24647   return jresult;
24648 }
24649
24650
24651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24652   int jresult ;
24653   int result;
24654
24655   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24656   jresult = (int)result;
24657   return jresult;
24658 }
24659
24660
24661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24662   int jresult ;
24663   int result;
24664
24665   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24666   jresult = (int)result;
24667   return jresult;
24668 }
24669
24670
24671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24672   int jresult ;
24673   int result;
24674
24675   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24676   jresult = (int)result;
24677   return jresult;
24678 }
24679
24680
24681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24682   int jresult ;
24683   int result;
24684
24685   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24686   jresult = (int)result;
24687   return jresult;
24688 }
24689
24690
24691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24692   void * jresult ;
24693   Dali::RenderTask::Property *result = 0 ;
24694
24695   {
24696     try {
24697       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24698     } catch (std::out_of_range& e) {
24699       {
24700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24701       };
24702     } catch (std::exception& e) {
24703       {
24704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24705       };
24706     } catch (...) {
24707       {
24708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24709       };
24710     }
24711   }
24712   jresult = (void *)result;
24713   return jresult;
24714 }
24715
24716
24717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24718   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24719
24720   arg1 = (Dali::RenderTask::Property *)jarg1;
24721   {
24722     try {
24723       delete arg1;
24724     } catch (std::out_of_range& e) {
24725       {
24726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24727       };
24728     } catch (std::exception& e) {
24729       {
24730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24731       };
24732     } catch (...) {
24733       {
24734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24735       };
24736     }
24737   }
24738 }
24739
24740
24741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24742   void * jresult ;
24743   bool (*result)(Dali::Vector2 &) = 0 ;
24744
24745   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24746   jresult = (void *)result;
24747   return jresult;
24748 }
24749
24750
24751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24752   void * jresult ;
24753   bool (*result)(Dali::Vector2 &) = 0 ;
24754
24755   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24756   jresult = (void *)result;
24757   return jresult;
24758 }
24759
24760
24761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24762   unsigned int jresult ;
24763   bool result;
24764
24765   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24766   jresult = result;
24767   return jresult;
24768 }
24769
24770
24771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24772   unsigned int jresult ;
24773   bool result;
24774
24775   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24776   jresult = result;
24777   return jresult;
24778 }
24779
24780
24781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24782   void * jresult ;
24783   Dali::Vector4 *result = 0 ;
24784
24785   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24786   jresult = (void *)result;
24787   return jresult;
24788 }
24789
24790
24791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24792   unsigned int jresult ;
24793   bool result;
24794
24795   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24796   jresult = result;
24797   return jresult;
24798 }
24799
24800
24801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24802   unsigned int jresult ;
24803   bool result;
24804
24805   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24806   jresult = result;
24807   return jresult;
24808 }
24809
24810
24811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24812   unsigned int jresult ;
24813   unsigned int result;
24814
24815   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24816   jresult = result;
24817   return jresult;
24818 }
24819
24820
24821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24822   void * jresult ;
24823   Dali::RenderTask *result = 0 ;
24824
24825   {
24826     try {
24827       result = (Dali::RenderTask *)new Dali::RenderTask();
24828     } catch (std::out_of_range& e) {
24829       {
24830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24831       };
24832     } catch (std::exception& e) {
24833       {
24834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24835       };
24836     } catch (...) {
24837       {
24838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24839       };
24840     }
24841   }
24842   jresult = (void *)result;
24843   return jresult;
24844 }
24845
24846
24847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24848   void * jresult ;
24849   Dali::BaseHandle arg1 ;
24850   Dali::BaseHandle *argp1 ;
24851   Dali::RenderTask result;
24852
24853   argp1 = (Dali::BaseHandle *)jarg1;
24854   if (!argp1) {
24855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24856     return 0;
24857   }
24858   arg1 = *argp1;
24859   {
24860     try {
24861       result = Dali::RenderTask::DownCast(arg1);
24862     } catch (std::out_of_range& e) {
24863       {
24864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24865       };
24866     } catch (std::exception& e) {
24867       {
24868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24869       };
24870     } catch (...) {
24871       {
24872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24873       };
24874     }
24875   }
24876   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24877   return jresult;
24878 }
24879
24880
24881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24882   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24883
24884   arg1 = (Dali::RenderTask *)jarg1;
24885   {
24886     try {
24887       delete arg1;
24888     } catch (std::out_of_range& e) {
24889       {
24890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24891       };
24892     } catch (std::exception& e) {
24893       {
24894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24899       };
24900     }
24901   }
24902 }
24903
24904
24905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24906   void * jresult ;
24907   Dali::RenderTask *arg1 = 0 ;
24908   Dali::RenderTask *result = 0 ;
24909
24910   arg1 = (Dali::RenderTask *)jarg1;
24911   if (!arg1) {
24912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24913     return 0;
24914   }
24915   {
24916     try {
24917       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24918     } catch (std::out_of_range& e) {
24919       {
24920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24921       };
24922     } catch (std::exception& e) {
24923       {
24924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24925       };
24926     } catch (...) {
24927       {
24928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24929       };
24930     }
24931   }
24932   jresult = (void *)result;
24933   return jresult;
24934 }
24935
24936
24937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24938   void * jresult ;
24939   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24940   Dali::RenderTask *arg2 = 0 ;
24941   Dali::RenderTask *result = 0 ;
24942
24943   arg1 = (Dali::RenderTask *)jarg1;
24944   arg2 = (Dali::RenderTask *)jarg2;
24945   if (!arg2) {
24946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24947     return 0;
24948   }
24949   {
24950     try {
24951       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24952     } catch (std::out_of_range& e) {
24953       {
24954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24955       };
24956     } catch (std::exception& e) {
24957       {
24958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24959       };
24960     } catch (...) {
24961       {
24962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24963       };
24964     }
24965   }
24966   jresult = (void *)result;
24967   return jresult;
24968 }
24969
24970
24971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24972   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24973   Dali::Actor arg2 ;
24974   Dali::Actor *argp2 ;
24975
24976   arg1 = (Dali::RenderTask *)jarg1;
24977   argp2 = (Dali::Actor *)jarg2;
24978   if (!argp2) {
24979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24980     return ;
24981   }
24982   arg2 = *argp2;
24983   {
24984     try {
24985       (arg1)->SetSourceActor(arg2);
24986     } catch (std::out_of_range& e) {
24987       {
24988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24989       };
24990     } catch (std::exception& e) {
24991       {
24992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24993       };
24994     } catch (...) {
24995       {
24996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24997       };
24998     }
24999   }
25000 }
25001
25002
25003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25004   void * jresult ;
25005   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25006   Dali::Actor result;
25007
25008   arg1 = (Dali::RenderTask *)jarg1;
25009   {
25010     try {
25011       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25019       };
25020     } catch (...) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25023       };
25024     }
25025   }
25026   jresult = new Dali::Actor((const Dali::Actor &)result);
25027   return jresult;
25028 }
25029
25030
25031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25032   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25033   bool arg2 ;
25034
25035   arg1 = (Dali::RenderTask *)jarg1;
25036   arg2 = jarg2 ? true : false;
25037   {
25038     try {
25039       (arg1)->SetExclusive(arg2);
25040     } catch (std::out_of_range& e) {
25041       {
25042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25043       };
25044     } catch (std::exception& e) {
25045       {
25046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25047       };
25048     } catch (...) {
25049       {
25050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25051       };
25052     }
25053   }
25054 }
25055
25056
25057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25058   unsigned int jresult ;
25059   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25060   bool result;
25061
25062   arg1 = (Dali::RenderTask *)jarg1;
25063   {
25064     try {
25065       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25066     } catch (std::out_of_range& e) {
25067       {
25068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25069       };
25070     } catch (std::exception& e) {
25071       {
25072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25073       };
25074     } catch (...) {
25075       {
25076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25077       };
25078     }
25079   }
25080   jresult = result;
25081   return jresult;
25082 }
25083
25084
25085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25086   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25087   bool arg2 ;
25088
25089   arg1 = (Dali::RenderTask *)jarg1;
25090   arg2 = jarg2 ? true : false;
25091   {
25092     try {
25093       (arg1)->SetInputEnabled(arg2);
25094     } catch (std::out_of_range& e) {
25095       {
25096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25097       };
25098     } catch (std::exception& e) {
25099       {
25100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25101       };
25102     } catch (...) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25105       };
25106     }
25107   }
25108 }
25109
25110
25111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25112   unsigned int jresult ;
25113   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25114   bool result;
25115
25116   arg1 = (Dali::RenderTask *)jarg1;
25117   {
25118     try {
25119       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25120     } catch (std::out_of_range& e) {
25121       {
25122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25123       };
25124     } catch (std::exception& e) {
25125       {
25126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25127       };
25128     } catch (...) {
25129       {
25130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25131       };
25132     }
25133   }
25134   jresult = result;
25135   return jresult;
25136 }
25137
25138
25139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25140   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25141   Dali::CameraActor arg2 ;
25142   Dali::CameraActor *argp2 ;
25143
25144   arg1 = (Dali::RenderTask *)jarg1;
25145   argp2 = (Dali::CameraActor *)jarg2;
25146   if (!argp2) {
25147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25148     return ;
25149   }
25150   arg2 = *argp2;
25151   {
25152     try {
25153       (arg1)->SetCameraActor(arg2);
25154     } catch (std::out_of_range& e) {
25155       {
25156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25157       };
25158     } catch (std::exception& e) {
25159       {
25160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25161       };
25162     } catch (...) {
25163       {
25164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25165       };
25166     }
25167   }
25168 }
25169
25170
25171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25172   void * jresult ;
25173   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25174   Dali::CameraActor result;
25175
25176   arg1 = (Dali::RenderTask *)jarg1;
25177   {
25178     try {
25179       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25180     } catch (std::out_of_range& e) {
25181       {
25182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25183       };
25184     } catch (std::exception& e) {
25185       {
25186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25187       };
25188     } catch (...) {
25189       {
25190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25191       };
25192     }
25193   }
25194   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25195   return jresult;
25196 }
25197
25198
25199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25200   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25201   Dali::FrameBufferImage arg2 ;
25202   Dali::FrameBufferImage *argp2 ;
25203
25204   arg1 = (Dali::RenderTask *)jarg1;
25205   argp2 = (Dali::FrameBufferImage *)jarg2;
25206   if (!argp2) {
25207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25208     return ;
25209   }
25210   arg2 = *argp2;
25211   {
25212     try {
25213       (arg1)->SetTargetFrameBuffer(arg2);
25214     } catch (std::out_of_range& e) {
25215       {
25216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25217       };
25218     } catch (std::exception& e) {
25219       {
25220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25221       };
25222     } catch (...) {
25223       {
25224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25225       };
25226     }
25227   }
25228 }
25229
25230
25231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25232   void * jresult ;
25233   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25234   Dali::FrameBufferImage result;
25235
25236   arg1 = (Dali::RenderTask *)jarg1;
25237   {
25238     try {
25239       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25240     } catch (std::out_of_range& e) {
25241       {
25242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25243       };
25244     } catch (std::exception& e) {
25245       {
25246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25247       };
25248     } catch (...) {
25249       {
25250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25251       };
25252     }
25253   }
25254   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25255   return jresult;
25256 }
25257
25258
25259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25260   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25261   Dali::FrameBuffer arg2 ;
25262   Dali::FrameBuffer *argp2 ;
25263
25264   arg1 = (Dali::RenderTask *)jarg1;
25265   argp2 = (Dali::FrameBuffer *)jarg2;
25266   if (!argp2) {
25267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25268     return ;
25269   }
25270   arg2 = *argp2;
25271   {
25272     try {
25273       (arg1)->SetFrameBuffer(arg2);
25274     } catch (std::out_of_range& e) {
25275       {
25276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25277       };
25278     } catch (std::exception& e) {
25279       {
25280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25281       };
25282     } catch (...) {
25283       {
25284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25285       };
25286     }
25287   }
25288 }
25289
25290
25291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25292   void * jresult ;
25293   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25294   Dali::FrameBuffer result;
25295
25296   arg1 = (Dali::RenderTask *)jarg1;
25297   {
25298     try {
25299       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25300     } catch (std::out_of_range& e) {
25301       {
25302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25303       };
25304     } catch (std::exception& e) {
25305       {
25306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (...) {
25309       {
25310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25311       };
25312     }
25313   }
25314   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25315   return jresult;
25316 }
25317
25318
25319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25320   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25321   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25322
25323   arg1 = (Dali::RenderTask *)jarg1;
25324   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25325   {
25326     try {
25327       (arg1)->SetScreenToFrameBufferFunction(arg2);
25328     } catch (std::out_of_range& e) {
25329       {
25330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25331       };
25332     } catch (std::exception& e) {
25333       {
25334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25335       };
25336     } catch (...) {
25337       {
25338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25339       };
25340     }
25341   }
25342 }
25343
25344
25345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25346   void * jresult ;
25347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25348   Dali::RenderTask::ScreenToFrameBufferFunction result;
25349
25350   arg1 = (Dali::RenderTask *)jarg1;
25351   {
25352     try {
25353       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25354     } catch (std::out_of_range& e) {
25355       {
25356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25357       };
25358     } catch (std::exception& e) {
25359       {
25360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25361       };
25362     } catch (...) {
25363       {
25364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25365       };
25366     }
25367   }
25368   jresult = (void *)result;
25369   return jresult;
25370 }
25371
25372
25373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25374   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25375   Dali::Actor arg2 ;
25376   Dali::Actor *argp2 ;
25377
25378   arg1 = (Dali::RenderTask *)jarg1;
25379   argp2 = (Dali::Actor *)jarg2;
25380   if (!argp2) {
25381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25382     return ;
25383   }
25384   arg2 = *argp2;
25385   {
25386     try {
25387       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25388     } catch (std::out_of_range& e) {
25389       {
25390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25391       };
25392     } catch (std::exception& e) {
25393       {
25394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25395       };
25396     } catch (...) {
25397       {
25398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25399       };
25400     }
25401   }
25402 }
25403
25404
25405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25406   void * jresult ;
25407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25408   Dali::Actor result;
25409
25410   arg1 = (Dali::RenderTask *)jarg1;
25411   {
25412     try {
25413       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25414     } catch (std::out_of_range& e) {
25415       {
25416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25417       };
25418     } catch (std::exception& e) {
25419       {
25420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25421       };
25422     } catch (...) {
25423       {
25424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25425       };
25426     }
25427   }
25428   jresult = new Dali::Actor((const Dali::Actor &)result);
25429   return jresult;
25430 }
25431
25432
25433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25434   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25435   Dali::Vector2 arg2 ;
25436   Dali::Vector2 *argp2 ;
25437
25438   arg1 = (Dali::RenderTask *)jarg1;
25439   argp2 = (Dali::Vector2 *)jarg2;
25440   if (!argp2) {
25441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25442     return ;
25443   }
25444   arg2 = *argp2;
25445   {
25446     try {
25447       (arg1)->SetViewportPosition(arg2);
25448     } catch (std::out_of_range& e) {
25449       {
25450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25451       };
25452     } catch (std::exception& e) {
25453       {
25454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25455       };
25456     } catch (...) {
25457       {
25458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25459       };
25460     }
25461   }
25462 }
25463
25464
25465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25466   void * jresult ;
25467   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25468   Dali::Vector2 result;
25469
25470   arg1 = (Dali::RenderTask *)jarg1;
25471   {
25472     try {
25473       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25474     } catch (std::out_of_range& e) {
25475       {
25476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25477       };
25478     } catch (std::exception& e) {
25479       {
25480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25481       };
25482     } catch (...) {
25483       {
25484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25485       };
25486     }
25487   }
25488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25489   return jresult;
25490 }
25491
25492
25493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25494   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25495   Dali::Vector2 arg2 ;
25496   Dali::Vector2 *argp2 ;
25497
25498   arg1 = (Dali::RenderTask *)jarg1;
25499   argp2 = (Dali::Vector2 *)jarg2;
25500   if (!argp2) {
25501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25502     return ;
25503   }
25504   arg2 = *argp2;
25505   {
25506     try {
25507       (arg1)->SetViewportSize(arg2);
25508     } catch (std::out_of_range& e) {
25509       {
25510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25511       };
25512     } catch (std::exception& e) {
25513       {
25514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25515       };
25516     } catch (...) {
25517       {
25518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25519       };
25520     }
25521   }
25522 }
25523
25524
25525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25526   void * jresult ;
25527   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25528   Dali::Vector2 result;
25529
25530   arg1 = (Dali::RenderTask *)jarg1;
25531   {
25532     try {
25533       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25534     } catch (std::out_of_range& e) {
25535       {
25536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25537       };
25538     } catch (std::exception& e) {
25539       {
25540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25541       };
25542     } catch (...) {
25543       {
25544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25545       };
25546     }
25547   }
25548   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25549   return jresult;
25550 }
25551
25552
25553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25554   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25555   Dali::Viewport arg2 ;
25556   Dali::Viewport *argp2 ;
25557
25558   arg1 = (Dali::RenderTask *)jarg1;
25559   argp2 = (Dali::Viewport *)jarg2;
25560   if (!argp2) {
25561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25562     return ;
25563   }
25564   arg2 = *argp2;
25565   {
25566     try {
25567       (arg1)->SetViewport(arg2);
25568     } catch (std::out_of_range& e) {
25569       {
25570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25571       };
25572     } catch (std::exception& e) {
25573       {
25574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25575       };
25576     } catch (...) {
25577       {
25578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25579       };
25580     }
25581   }
25582 }
25583
25584
25585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25586   void * jresult ;
25587   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25588   Dali::Viewport result;
25589
25590   arg1 = (Dali::RenderTask *)jarg1;
25591   {
25592     try {
25593       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25594     } catch (std::out_of_range& e) {
25595       {
25596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25597       };
25598     } catch (std::exception& e) {
25599       {
25600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25601       };
25602     } catch (...) {
25603       {
25604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25605       };
25606     }
25607   }
25608   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25609   return jresult;
25610 }
25611
25612
25613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25614   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25615   Dali::Vector4 *arg2 = 0 ;
25616
25617   arg1 = (Dali::RenderTask *)jarg1;
25618   arg2 = (Dali::Vector4 *)jarg2;
25619   if (!arg2) {
25620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25621     return ;
25622   }
25623   {
25624     try {
25625       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25626     } catch (std::out_of_range& e) {
25627       {
25628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25629       };
25630     } catch (std::exception& e) {
25631       {
25632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25633       };
25634     } catch (...) {
25635       {
25636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25637       };
25638     }
25639   }
25640 }
25641
25642
25643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25644   void * jresult ;
25645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25646   Dali::Vector4 result;
25647
25648   arg1 = (Dali::RenderTask *)jarg1;
25649   {
25650     try {
25651       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25652     } catch (std::out_of_range& e) {
25653       {
25654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25655       };
25656     } catch (std::exception& e) {
25657       {
25658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25659       };
25660     } catch (...) {
25661       {
25662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25663       };
25664     }
25665   }
25666   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25667   return jresult;
25668 }
25669
25670
25671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25672   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25673   bool arg2 ;
25674
25675   arg1 = (Dali::RenderTask *)jarg1;
25676   arg2 = jarg2 ? true : false;
25677   {
25678     try {
25679       (arg1)->SetClearEnabled(arg2);
25680     } catch (std::out_of_range& e) {
25681       {
25682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25683       };
25684     } catch (std::exception& e) {
25685       {
25686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25687       };
25688     } catch (...) {
25689       {
25690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25691       };
25692     }
25693   }
25694 }
25695
25696
25697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25698   unsigned int jresult ;
25699   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25700   bool result;
25701
25702   arg1 = (Dali::RenderTask *)jarg1;
25703   {
25704     try {
25705       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25706     } catch (std::out_of_range& e) {
25707       {
25708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25709       };
25710     } catch (std::exception& e) {
25711       {
25712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25713       };
25714     } catch (...) {
25715       {
25716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25717       };
25718     }
25719   }
25720   jresult = result;
25721   return jresult;
25722 }
25723
25724
25725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25726   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25727   bool arg2 ;
25728
25729   arg1 = (Dali::RenderTask *)jarg1;
25730   arg2 = jarg2 ? true : false;
25731   {
25732     try {
25733       (arg1)->SetCullMode(arg2);
25734     } catch (std::out_of_range& e) {
25735       {
25736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25737       };
25738     } catch (std::exception& e) {
25739       {
25740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25741       };
25742     } catch (...) {
25743       {
25744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25745       };
25746     }
25747   }
25748 }
25749
25750
25751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25752   unsigned int jresult ;
25753   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25754   bool result;
25755
25756   arg1 = (Dali::RenderTask *)jarg1;
25757   {
25758     try {
25759       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25760     } catch (std::out_of_range& e) {
25761       {
25762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25763       };
25764     } catch (std::exception& e) {
25765       {
25766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25767       };
25768     } catch (...) {
25769       {
25770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25771       };
25772     }
25773   }
25774   jresult = result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25780   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25781   unsigned int arg2 ;
25782
25783   arg1 = (Dali::RenderTask *)jarg1;
25784   arg2 = (unsigned int)jarg2;
25785   {
25786     try {
25787       (arg1)->SetRefreshRate(arg2);
25788     } catch (std::out_of_range& e) {
25789       {
25790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25791       };
25792     } catch (std::exception& e) {
25793       {
25794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25799       };
25800     }
25801   }
25802 }
25803
25804
25805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25806   unsigned int jresult ;
25807   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25808   unsigned int result;
25809
25810   arg1 = (Dali::RenderTask *)jarg1;
25811   {
25812     try {
25813       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (...) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25825       };
25826     }
25827   }
25828   jresult = result;
25829   return jresult;
25830 }
25831
25832
25833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25834   unsigned int jresult ;
25835   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25836   Dali::Vector3 *arg2 = 0 ;
25837   float *arg3 = 0 ;
25838   float *arg4 = 0 ;
25839   bool result;
25840
25841   arg1 = (Dali::RenderTask *)jarg1;
25842   arg2 = (Dali::Vector3 *)jarg2;
25843   if (!arg2) {
25844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25845     return 0;
25846   }
25847   arg3 = (float *)jarg3;
25848   arg4 = (float *)jarg4;
25849   {
25850     try {
25851       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25852     } catch (std::out_of_range& e) {
25853       {
25854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25855       };
25856     } catch (std::exception& e) {
25857       {
25858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (...) {
25861       {
25862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25863       };
25864     }
25865   }
25866   jresult = result;
25867   return jresult;
25868 }
25869
25870
25871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25872   unsigned int jresult ;
25873   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25874   Dali::Actor arg2 ;
25875   float arg3 ;
25876   float arg4 ;
25877   float *arg5 = 0 ;
25878   float *arg6 = 0 ;
25879   Dali::Actor *argp2 ;
25880   bool result;
25881
25882   arg1 = (Dali::RenderTask *)jarg1;
25883   argp2 = (Dali::Actor *)jarg2;
25884   if (!argp2) {
25885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25886     return 0;
25887   }
25888   arg2 = *argp2;
25889   arg3 = (float)jarg3;
25890   arg4 = (float)jarg4;
25891   arg5 = (float *)jarg5;
25892   arg6 = (float *)jarg6;
25893   {
25894     try {
25895       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (...) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25907       };
25908     }
25909   }
25910   jresult = result;
25911   return jresult;
25912 }
25913
25914
25915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25916   void * jresult ;
25917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25918   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25919
25920   arg1 = (Dali::RenderTask *)jarg1;
25921   {
25922     try {
25923       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25924     } catch (std::out_of_range& e) {
25925       {
25926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25927       };
25928     } catch (std::exception& e) {
25929       {
25930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25931       };
25932     } catch (...) {
25933       {
25934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25935       };
25936     }
25937   }
25938   jresult = (void *)result;
25939   return jresult;
25940 }
25941
25942
25943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25944   void * jresult ;
25945   int arg1 ;
25946   Dali::TouchPoint::State arg2 ;
25947   float arg3 ;
25948   float arg4 ;
25949   Dali::TouchPoint *result = 0 ;
25950
25951   arg1 = (int)jarg1;
25952   arg2 = (Dali::TouchPoint::State)jarg2;
25953   arg3 = (float)jarg3;
25954   arg4 = (float)jarg4;
25955   {
25956     try {
25957       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25958     } catch (std::out_of_range& e) {
25959       {
25960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25961       };
25962     } catch (std::exception& e) {
25963       {
25964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25965       };
25966     } catch (...) {
25967       {
25968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25969       };
25970     }
25971   }
25972   jresult = (void *)result;
25973   return jresult;
25974 }
25975
25976
25977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25978   void * jresult ;
25979   int arg1 ;
25980   Dali::TouchPoint::State arg2 ;
25981   float arg3 ;
25982   float arg4 ;
25983   float arg5 ;
25984   float arg6 ;
25985   Dali::TouchPoint *result = 0 ;
25986
25987   arg1 = (int)jarg1;
25988   arg2 = (Dali::TouchPoint::State)jarg2;
25989   arg3 = (float)jarg3;
25990   arg4 = (float)jarg4;
25991   arg5 = (float)jarg5;
25992   arg6 = (float)jarg6;
25993   {
25994     try {
25995       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25996     } catch (std::out_of_range& e) {
25997       {
25998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25999       };
26000     } catch (std::exception& e) {
26001       {
26002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26003       };
26004     } catch (...) {
26005       {
26006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26007       };
26008     }
26009   }
26010   jresult = (void *)result;
26011   return jresult;
26012 }
26013
26014
26015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26016   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26017
26018   arg1 = (Dali::TouchPoint *)jarg1;
26019   {
26020     try {
26021       delete arg1;
26022     } catch (std::out_of_range& e) {
26023       {
26024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26025       };
26026     } catch (std::exception& e) {
26027       {
26028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26029       };
26030     } catch (...) {
26031       {
26032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26033       };
26034     }
26035   }
26036 }
26037
26038
26039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26040   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26041   int arg2 ;
26042
26043   arg1 = (Dali::TouchPoint *)jarg1;
26044   arg2 = (int)jarg2;
26045   if (arg1) (arg1)->deviceId = arg2;
26046 }
26047
26048
26049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26050   int jresult ;
26051   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26052   int result;
26053
26054   arg1 = (Dali::TouchPoint *)jarg1;
26055   result = (int) ((arg1)->deviceId);
26056   jresult = result;
26057   return jresult;
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26062   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26063   Dali::TouchPoint::State arg2 ;
26064
26065   arg1 = (Dali::TouchPoint *)jarg1;
26066   arg2 = (Dali::TouchPoint::State)jarg2;
26067   if (arg1) (arg1)->state = arg2;
26068 }
26069
26070
26071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26072   int jresult ;
26073   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26074   Dali::TouchPoint::State result;
26075
26076   arg1 = (Dali::TouchPoint *)jarg1;
26077   result = (Dali::TouchPoint::State) ((arg1)->state);
26078   jresult = (int)result;
26079   return jresult;
26080 }
26081
26082
26083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26084   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26085   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26086
26087   arg1 = (Dali::TouchPoint *)jarg1;
26088   arg2 = (Dali::Actor *)jarg2;
26089   if (arg1) (arg1)->hitActor = *arg2;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26094   void * jresult ;
26095   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26096   Dali::Actor *result = 0 ;
26097
26098   arg1 = (Dali::TouchPoint *)jarg1;
26099   result = (Dali::Actor *)& ((arg1)->hitActor);
26100   jresult = (void *)result;
26101   return jresult;
26102 }
26103
26104
26105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26106   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26107   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26108
26109   arg1 = (Dali::TouchPoint *)jarg1;
26110   arg2 = (Dali::Vector2 *)jarg2;
26111   if (arg1) (arg1)->local = *arg2;
26112 }
26113
26114
26115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26116   void * jresult ;
26117   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26118   Dali::Vector2 *result = 0 ;
26119
26120   arg1 = (Dali::TouchPoint *)jarg1;
26121   result = (Dali::Vector2 *)& ((arg1)->local);
26122   jresult = (void *)result;
26123   return jresult;
26124 }
26125
26126
26127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26128   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26129   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26130
26131   arg1 = (Dali::TouchPoint *)jarg1;
26132   arg2 = (Dali::Vector2 *)jarg2;
26133   if (arg1) (arg1)->screen = *arg2;
26134 }
26135
26136
26137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26138   void * jresult ;
26139   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26140   Dali::Vector2 *result = 0 ;
26141
26142   arg1 = (Dali::TouchPoint *)jarg1;
26143   result = (Dali::Vector2 *)& ((arg1)->screen);
26144   jresult = (void *)result;
26145   return jresult;
26146 }
26147
26148
26149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26150   void * jresult ;
26151   Dali::TouchData *result = 0 ;
26152
26153   {
26154     try {
26155       result = (Dali::TouchData *)new Dali::TouchData();
26156     } catch (std::out_of_range& e) {
26157       {
26158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26159       };
26160     } catch (std::exception& e) {
26161       {
26162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26163       };
26164     } catch (...) {
26165       {
26166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26167       };
26168     }
26169   }
26170   jresult = (void *)result;
26171   return jresult;
26172 }
26173
26174
26175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26176   void * jresult ;
26177   Dali::TouchData *arg1 = 0 ;
26178   Dali::TouchData *result = 0 ;
26179
26180   arg1 = (Dali::TouchData *)jarg1;
26181   if (!arg1) {
26182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26183     return 0;
26184   }
26185   {
26186     try {
26187       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26188     } catch (std::out_of_range& e) {
26189       {
26190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26191       };
26192     } catch (std::exception& e) {
26193       {
26194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (...) {
26197       {
26198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26199       };
26200     }
26201   }
26202   jresult = (void *)result;
26203   return jresult;
26204 }
26205
26206
26207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26208   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26209
26210   arg1 = (Dali::TouchData *)jarg1;
26211   {
26212     try {
26213       delete arg1;
26214     } catch (std::out_of_range& e) {
26215       {
26216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26217       };
26218     } catch (std::exception& e) {
26219       {
26220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26221       };
26222     } catch (...) {
26223       {
26224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26225       };
26226     }
26227   }
26228 }
26229
26230
26231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26232   void * jresult ;
26233   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26234   Dali::TouchData *arg2 = 0 ;
26235   Dali::TouchData *result = 0 ;
26236
26237   arg1 = (Dali::TouchData *)jarg1;
26238   arg2 = (Dali::TouchData *)jarg2;
26239   if (!arg2) {
26240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26241     return 0;
26242   }
26243   {
26244     try {
26245       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26246     } catch (std::out_of_range& e) {
26247       {
26248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26249       };
26250     } catch (std::exception& e) {
26251       {
26252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26253       };
26254     } catch (...) {
26255       {
26256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26257       };
26258     }
26259   }
26260   jresult = (void *)result;
26261   return jresult;
26262 }
26263
26264
26265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26266   unsigned long jresult ;
26267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26268   unsigned long result;
26269
26270   arg1 = (Dali::TouchData *)jarg1;
26271   {
26272     try {
26273       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (...) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26285       };
26286     }
26287   }
26288   jresult = (unsigned long)result;
26289   return jresult;
26290 }
26291
26292
26293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26294   unsigned long jresult ;
26295   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26296   std::size_t result;
26297
26298   arg1 = (Dali::TouchData *)jarg1;
26299   {
26300     try {
26301       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26302     } catch (std::out_of_range& e) {
26303       {
26304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26305       };
26306     } catch (std::exception& e) {
26307       {
26308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26309       };
26310     } catch (...) {
26311       {
26312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26313       };
26314     }
26315   }
26316   jresult = (unsigned long)result;
26317   return jresult;
26318 }
26319
26320
26321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26322   int jresult ;
26323   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26324   std::size_t arg2 ;
26325   int32_t result;
26326
26327   arg1 = (Dali::TouchData *)jarg1;
26328   arg2 = (std::size_t)jarg2;
26329   {
26330     try {
26331       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26332     } catch (std::out_of_range& e) {
26333       {
26334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26335       };
26336     } catch (std::exception& e) {
26337       {
26338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26339       };
26340     } catch (...) {
26341       {
26342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26343       };
26344     }
26345   }
26346   jresult = result;
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26352   int jresult ;
26353   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26354   std::size_t arg2 ;
26355   Dali::PointState::Type result;
26356
26357   arg1 = (Dali::TouchData *)jarg1;
26358   arg2 = (std::size_t)jarg2;
26359   {
26360     try {
26361       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (...) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26373       };
26374     }
26375   }
26376   jresult = (int)result;
26377   return jresult;
26378 }
26379
26380
26381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26382   void * jresult ;
26383   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26384   std::size_t arg2 ;
26385   Dali::Actor result;
26386
26387   arg1 = (Dali::TouchData *)jarg1;
26388   arg2 = (std::size_t)jarg2;
26389   {
26390     try {
26391       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26392     } catch (std::out_of_range& e) {
26393       {
26394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26395       };
26396     } catch (std::exception& e) {
26397       {
26398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26399       };
26400     } catch (...) {
26401       {
26402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26403       };
26404     }
26405   }
26406   jresult = new Dali::Actor((const Dali::Actor &)result);
26407   return jresult;
26408 }
26409
26410
26411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26412   void * jresult ;
26413   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26414   std::size_t arg2 ;
26415   Dali::Vector2 *result = 0 ;
26416
26417   arg1 = (Dali::TouchData *)jarg1;
26418   arg2 = (std::size_t)jarg2;
26419   {
26420     try {
26421       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26422     } catch (std::out_of_range& e) {
26423       {
26424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26425       };
26426     } catch (std::exception& e) {
26427       {
26428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26429       };
26430     } catch (...) {
26431       {
26432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26433       };
26434     }
26435   }
26436   jresult = (void *)result;
26437   return jresult;
26438 }
26439
26440
26441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26442   void * jresult ;
26443   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26444   std::size_t arg2 ;
26445   Dali::Vector2 *result = 0 ;
26446
26447   arg1 = (Dali::TouchData *)jarg1;
26448   arg2 = (std::size_t)jarg2;
26449   {
26450     try {
26451       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26452     } catch (std::out_of_range& e) {
26453       {
26454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26455       };
26456     } catch (std::exception& e) {
26457       {
26458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26459       };
26460     } catch (...) {
26461       {
26462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26463       };
26464     }
26465   }
26466   jresult = (void *)result;
26467   return jresult;
26468 }
26469
26470
26471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26472   float jresult ;
26473   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26474   std::size_t arg2 ;
26475   float result;
26476
26477   arg1 = (Dali::TouchData *)jarg1;
26478   arg2 = (std::size_t)jarg2;
26479   {
26480     try {
26481       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26482     } catch (std::out_of_range& e) {
26483       {
26484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26485       };
26486     } catch (std::exception& e) {
26487       {
26488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26489       };
26490     } catch (...) {
26491       {
26492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26493       };
26494     }
26495   }
26496   jresult = result;
26497   return jresult;
26498 }
26499
26500
26501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26502   void * jresult ;
26503   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26504   std::size_t arg2 ;
26505   Dali::Vector2 *result = 0 ;
26506
26507   arg1 = (Dali::TouchData *)jarg1;
26508   arg2 = (std::size_t)jarg2;
26509   {
26510     try {
26511       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26512     } catch (std::out_of_range& e) {
26513       {
26514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26515       };
26516     } catch (std::exception& e) {
26517       {
26518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26519       };
26520     } catch (...) {
26521       {
26522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26523       };
26524     }
26525   }
26526   jresult = (void *)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26532   float jresult ;
26533   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26534   std::size_t arg2 ;
26535   float result;
26536
26537   arg1 = (Dali::TouchData *)jarg1;
26538   arg2 = (std::size_t)jarg2;
26539   {
26540     try {
26541       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26542     } catch (std::out_of_range& e) {
26543       {
26544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26545       };
26546     } catch (std::exception& e) {
26547       {
26548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26549       };
26550     } catch (...) {
26551       {
26552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26553       };
26554     }
26555   }
26556   jresult = result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26562   void * jresult ;
26563   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26564   std::size_t arg2 ;
26565   Dali::Degree result;
26566
26567   arg1 = (Dali::TouchData *)jarg1;
26568   arg2 = (std::size_t)jarg2;
26569   {
26570     try {
26571       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26572     } catch (std::out_of_range& e) {
26573       {
26574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26575       };
26576     } catch (std::exception& e) {
26577       {
26578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26579       };
26580     } catch (...) {
26581       {
26582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26583       };
26584     }
26585   }
26586   jresult = new Dali::Degree((const Dali::Degree &)result);
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26592   void * jresult ;
26593   Dali::GestureDetector *result = 0 ;
26594
26595   {
26596     try {
26597       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26598     } catch (std::out_of_range& e) {
26599       {
26600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26601       };
26602     } catch (std::exception& e) {
26603       {
26604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26605       };
26606     } catch (...) {
26607       {
26608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26609       };
26610     }
26611   }
26612   jresult = (void *)result;
26613   return jresult;
26614 }
26615
26616
26617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26618   void * jresult ;
26619   Dali::BaseHandle arg1 ;
26620   Dali::BaseHandle *argp1 ;
26621   Dali::GestureDetector result;
26622
26623   argp1 = (Dali::BaseHandle *)jarg1;
26624   if (!argp1) {
26625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26626     return 0;
26627   }
26628   arg1 = *argp1;
26629   {
26630     try {
26631       result = Dali::GestureDetector::DownCast(arg1);
26632     } catch (std::out_of_range& e) {
26633       {
26634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26635       };
26636     } catch (std::exception& e) {
26637       {
26638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26639       };
26640     } catch (...) {
26641       {
26642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26643       };
26644     }
26645   }
26646   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26652   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26653
26654   arg1 = (Dali::GestureDetector *)jarg1;
26655   {
26656     try {
26657       delete arg1;
26658     } catch (std::out_of_range& e) {
26659       {
26660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26661       };
26662     } catch (std::exception& e) {
26663       {
26664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26665       };
26666     } catch (...) {
26667       {
26668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26669       };
26670     }
26671   }
26672 }
26673
26674
26675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26676   void * jresult ;
26677   Dali::GestureDetector *arg1 = 0 ;
26678   Dali::GestureDetector *result = 0 ;
26679
26680   arg1 = (Dali::GestureDetector *)jarg1;
26681   if (!arg1) {
26682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26683     return 0;
26684   }
26685   {
26686     try {
26687       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26688     } catch (std::out_of_range& e) {
26689       {
26690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26691       };
26692     } catch (std::exception& e) {
26693       {
26694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26695       };
26696     } catch (...) {
26697       {
26698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26699       };
26700     }
26701   }
26702   jresult = (void *)result;
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26708   void * jresult ;
26709   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26710   Dali::GestureDetector *arg2 = 0 ;
26711   Dali::GestureDetector *result = 0 ;
26712
26713   arg1 = (Dali::GestureDetector *)jarg1;
26714   arg2 = (Dali::GestureDetector *)jarg2;
26715   if (!arg2) {
26716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26717     return 0;
26718   }
26719   {
26720     try {
26721       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26722     } catch (std::out_of_range& e) {
26723       {
26724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26725       };
26726     } catch (std::exception& e) {
26727       {
26728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26729       };
26730     } catch (...) {
26731       {
26732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26733       };
26734     }
26735   }
26736   jresult = (void *)result;
26737   return jresult;
26738 }
26739
26740
26741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26742   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26743   Dali::Actor arg2 ;
26744   Dali::Actor *argp2 ;
26745
26746   arg1 = (Dali::GestureDetector *)jarg1;
26747   argp2 = (Dali::Actor *)jarg2;
26748   if (!argp2) {
26749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26750     return ;
26751   }
26752   arg2 = *argp2;
26753   {
26754     try {
26755       (arg1)->Attach(arg2);
26756     } catch (std::out_of_range& e) {
26757       {
26758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26759       };
26760     } catch (std::exception& e) {
26761       {
26762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26763       };
26764     } catch (...) {
26765       {
26766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26767       };
26768     }
26769   }
26770 }
26771
26772
26773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26774   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26775   Dali::Actor arg2 ;
26776   Dali::Actor *argp2 ;
26777
26778   arg1 = (Dali::GestureDetector *)jarg1;
26779   argp2 = (Dali::Actor *)jarg2;
26780   if (!argp2) {
26781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26782     return ;
26783   }
26784   arg2 = *argp2;
26785   {
26786     try {
26787       (arg1)->Detach(arg2);
26788     } catch (std::out_of_range& e) {
26789       {
26790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26791       };
26792     } catch (std::exception& e) {
26793       {
26794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26795       };
26796     } catch (...) {
26797       {
26798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26799       };
26800     }
26801   }
26802 }
26803
26804
26805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26806   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26807
26808   arg1 = (Dali::GestureDetector *)jarg1;
26809   {
26810     try {
26811       (arg1)->DetachAll();
26812     } catch (std::out_of_range& e) {
26813       {
26814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26815       };
26816     } catch (std::exception& e) {
26817       {
26818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26819       };
26820     } catch (...) {
26821       {
26822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26823       };
26824     }
26825   }
26826 }
26827
26828
26829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26830   unsigned long jresult ;
26831   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26832   size_t result;
26833
26834   arg1 = (Dali::GestureDetector *)jarg1;
26835   {
26836     try {
26837       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26838     } catch (std::out_of_range& e) {
26839       {
26840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26841       };
26842     } catch (std::exception& e) {
26843       {
26844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26845       };
26846     } catch (...) {
26847       {
26848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26849       };
26850     }
26851   }
26852   jresult = (unsigned long)result;
26853   return jresult;
26854 }
26855
26856
26857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26858   void * jresult ;
26859   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26860   size_t arg2 ;
26861   Dali::Actor result;
26862
26863   arg1 = (Dali::GestureDetector *)jarg1;
26864   arg2 = (size_t)jarg2;
26865   {
26866     try {
26867       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26868     } catch (std::out_of_range& e) {
26869       {
26870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26871       };
26872     } catch (std::exception& e) {
26873       {
26874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26875       };
26876     } catch (...) {
26877       {
26878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26879       };
26880     }
26881   }
26882   jresult = new Dali::Actor((const Dali::Actor &)result);
26883   return jresult;
26884 }
26885
26886
26887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26888   void * jresult ;
26889   Dali::Gesture *arg1 = 0 ;
26890   Dali::Gesture *result = 0 ;
26891
26892   arg1 = (Dali::Gesture *)jarg1;
26893   if (!arg1) {
26894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26895     return 0;
26896   }
26897   {
26898     try {
26899       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26900     } catch (std::out_of_range& e) {
26901       {
26902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26903       };
26904     } catch (std::exception& e) {
26905       {
26906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26907       };
26908     } catch (...) {
26909       {
26910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26911       };
26912     }
26913   }
26914   jresult = (void *)result;
26915   return jresult;
26916 }
26917
26918
26919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26920   void * jresult ;
26921   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26922   Dali::Gesture *arg2 = 0 ;
26923   Dali::Gesture *result = 0 ;
26924
26925   arg1 = (Dali::Gesture *)jarg1;
26926   arg2 = (Dali::Gesture *)jarg2;
26927   if (!arg2) {
26928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26929     return 0;
26930   }
26931   {
26932     try {
26933       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26941       };
26942     } catch (...) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26945       };
26946     }
26947   }
26948   jresult = (void *)result;
26949   return jresult;
26950 }
26951
26952
26953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26954   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26955
26956   arg1 = (Dali::Gesture *)jarg1;
26957   {
26958     try {
26959       delete arg1;
26960     } catch (std::out_of_range& e) {
26961       {
26962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26963       };
26964     } catch (std::exception& e) {
26965       {
26966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26967       };
26968     } catch (...) {
26969       {
26970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26971       };
26972     }
26973   }
26974 }
26975
26976
26977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26978   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26979   Dali::Gesture::Type arg2 ;
26980
26981   arg1 = (Dali::Gesture *)jarg1;
26982   arg2 = (Dali::Gesture::Type)jarg2;
26983   if (arg1) (arg1)->type = arg2;
26984 }
26985
26986
26987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26988   int jresult ;
26989   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26990   Dali::Gesture::Type result;
26991
26992   arg1 = (Dali::Gesture *)jarg1;
26993   result = (Dali::Gesture::Type) ((arg1)->type);
26994   jresult = (int)result;
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
27000   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27001   Dali::Gesture::State arg2 ;
27002
27003   arg1 = (Dali::Gesture *)jarg1;
27004   arg2 = (Dali::Gesture::State)jarg2;
27005   if (arg1) (arg1)->state = arg2;
27006 }
27007
27008
27009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27010   int jresult ;
27011   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27012   Dali::Gesture::State result;
27013
27014   arg1 = (Dali::Gesture *)jarg1;
27015   result = (Dali::Gesture::State) ((arg1)->state);
27016   jresult = (int)result;
27017   return jresult;
27018 }
27019
27020
27021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27022   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27023   unsigned int arg2 ;
27024
27025   arg1 = (Dali::Gesture *)jarg1;
27026   arg2 = (unsigned int)jarg2;
27027   if (arg1) (arg1)->time = arg2;
27028 }
27029
27030
27031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27032   unsigned int jresult ;
27033   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27034   unsigned int result;
27035
27036   arg1 = (Dali::Gesture *)jarg1;
27037   result = (unsigned int) ((arg1)->time);
27038   jresult = result;
27039   return jresult;
27040 }
27041
27042
27043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27044   void * jresult ;
27045   Dali::HoverEvent *result = 0 ;
27046
27047   {
27048     try {
27049       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27050     } catch (std::out_of_range& e) {
27051       {
27052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27053       };
27054     } catch (std::exception& e) {
27055       {
27056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27057       };
27058     } catch (...) {
27059       {
27060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27061       };
27062     }
27063   }
27064   jresult = (void *)result;
27065   return jresult;
27066 }
27067
27068
27069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27070   void * jresult ;
27071   unsigned long arg1 ;
27072   Dali::HoverEvent *result = 0 ;
27073
27074   arg1 = (unsigned long)jarg1;
27075   {
27076     try {
27077       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27078     } catch (std::out_of_range& e) {
27079       {
27080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (std::exception& e) {
27083       {
27084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27085       };
27086     } catch (...) {
27087       {
27088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27089       };
27090     }
27091   }
27092   jresult = (void *)result;
27093   return jresult;
27094 }
27095
27096
27097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27098   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27099
27100   arg1 = (Dali::HoverEvent *)jarg1;
27101   {
27102     try {
27103       delete arg1;
27104     } catch (std::out_of_range& e) {
27105       {
27106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27107       };
27108     } catch (std::exception& e) {
27109       {
27110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27111       };
27112     } catch (...) {
27113       {
27114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27115       };
27116     }
27117   }
27118 }
27119
27120
27121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27122   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27123   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27124
27125   arg1 = (Dali::HoverEvent *)jarg1;
27126   arg2 = (Dali::TouchPointContainer *)jarg2;
27127   if (arg1) (arg1)->points = *arg2;
27128 }
27129
27130
27131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27132   void * jresult ;
27133   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27134   Dali::TouchPointContainer *result = 0 ;
27135
27136   arg1 = (Dali::HoverEvent *)jarg1;
27137   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27138   jresult = (void *)result;
27139   return jresult;
27140 }
27141
27142
27143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27144   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27145   unsigned long arg2 ;
27146
27147   arg1 = (Dali::HoverEvent *)jarg1;
27148   arg2 = (unsigned long)jarg2;
27149   if (arg1) (arg1)->time = arg2;
27150 }
27151
27152
27153 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27154   unsigned long jresult ;
27155   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27156   unsigned long result;
27157
27158   arg1 = (Dali::HoverEvent *)jarg1;
27159   result = (unsigned long) ((arg1)->time);
27160   jresult = (unsigned long)result;
27161   return jresult;
27162 }
27163
27164
27165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27166   unsigned int jresult ;
27167   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27168   unsigned int result;
27169
27170   arg1 = (Dali::HoverEvent *)jarg1;
27171   {
27172     try {
27173       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27174     } catch (std::out_of_range& e) {
27175       {
27176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27177       };
27178     } catch (std::exception& e) {
27179       {
27180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27181       };
27182     } catch (...) {
27183       {
27184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27185       };
27186     }
27187   }
27188   jresult = result;
27189   return jresult;
27190 }
27191
27192
27193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27194   void * jresult ;
27195   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27196   unsigned int arg2 ;
27197   Dali::TouchPoint *result = 0 ;
27198
27199   arg1 = (Dali::HoverEvent *)jarg1;
27200   arg2 = (unsigned int)jarg2;
27201   {
27202     try {
27203       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27204     } catch (std::out_of_range& e) {
27205       {
27206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27207       };
27208     } catch (std::exception& e) {
27209       {
27210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27211       };
27212     } catch (...) {
27213       {
27214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27215       };
27216     }
27217   }
27218   jresult = (void *)result;
27219   return jresult;
27220 }
27221
27222
27223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27224   void * jresult ;
27225   Dali::KeyEvent *result = 0 ;
27226
27227   {
27228     try {
27229       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27230     } catch (std::out_of_range& e) {
27231       {
27232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27233       };
27234     } catch (std::exception& e) {
27235       {
27236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27237       };
27238     } catch (...) {
27239       {
27240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27241       };
27242     }
27243   }
27244   jresult = (void *)result;
27245   return jresult;
27246 }
27247
27248
27249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27250   void * jresult ;
27251   std::string *arg1 = 0 ;
27252   std::string *arg2 = 0 ;
27253   int arg3 ;
27254   int arg4 ;
27255   unsigned long arg5 ;
27256   Dali::KeyEvent::State *arg6 = 0 ;
27257   Dali::KeyEvent::State temp6 ;
27258   Dali::KeyEvent *result = 0 ;
27259
27260   if (!jarg1) {
27261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27262     return 0;
27263   }
27264   std::string arg1_str(jarg1);
27265   arg1 = &arg1_str;
27266   if (!jarg2) {
27267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27268     return 0;
27269   }
27270   std::string arg2_str(jarg2);
27271   arg2 = &arg2_str;
27272   arg3 = (int)jarg3;
27273   arg4 = (int)jarg4;
27274   arg5 = (unsigned long)jarg5;
27275   temp6 = (Dali::KeyEvent::State)jarg6;
27276   arg6 = &temp6;
27277   {
27278     try {
27279       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27280     } catch (std::out_of_range& e) {
27281       {
27282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27283       };
27284     } catch (std::exception& e) {
27285       {
27286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27287       };
27288     } catch (...) {
27289       {
27290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27291       };
27292     }
27293   }
27294   jresult = (void *)result;
27295
27296   //argout typemap for const std::string&
27297
27298
27299   //argout typemap for const std::string&
27300
27301   return jresult;
27302 }
27303
27304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27305   void * jresult ;
27306   Dali::KeyEvent *arg1 = 0 ;
27307   Dali::KeyEvent *result = 0 ;
27308
27309   arg1 = (Dali::KeyEvent *)jarg1;
27310   if (!arg1) {
27311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27312     return 0;
27313   }
27314   {
27315     try {
27316       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27317     } catch (std::out_of_range& e) {
27318       {
27319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27320       };
27321     } catch (std::exception& e) {
27322       {
27323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (...) {
27326       {
27327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27328       };
27329     }
27330   }
27331   jresult = (void *)result;
27332   return jresult;
27333 }
27334
27335
27336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27337   void * jresult ;
27338   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27339   Dali::KeyEvent *arg2 = 0 ;
27340   Dali::KeyEvent *result = 0 ;
27341
27342   arg1 = (Dali::KeyEvent *)jarg1;
27343   arg2 = (Dali::KeyEvent *)jarg2;
27344   if (!arg2) {
27345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27346     return 0;
27347   }
27348   {
27349     try {
27350       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27351     } catch (std::out_of_range& e) {
27352       {
27353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27354       };
27355     } catch (std::exception& e) {
27356       {
27357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27358       };
27359     } catch (...) {
27360       {
27361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27362       };
27363     }
27364   }
27365   jresult = (void *)result;
27366   return jresult;
27367 }
27368
27369
27370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27371   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27372
27373   arg1 = (Dali::KeyEvent *)jarg1;
27374   {
27375     try {
27376       delete arg1;
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27384       };
27385     } catch (...) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27388       };
27389     }
27390   }
27391 }
27392
27393
27394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27395   unsigned int jresult ;
27396   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27397   bool result;
27398
27399   arg1 = (Dali::KeyEvent *)jarg1;
27400   {
27401     try {
27402       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27403     } catch (std::out_of_range& e) {
27404       {
27405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27406       };
27407     } catch (std::exception& e) {
27408       {
27409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27410       };
27411     } catch (...) {
27412       {
27413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27414       };
27415     }
27416   }
27417   jresult = result;
27418   return jresult;
27419 }
27420
27421
27422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27423   unsigned int jresult ;
27424   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27425   bool result;
27426
27427   arg1 = (Dali::KeyEvent *)jarg1;
27428   {
27429     try {
27430       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27431     } catch (std::out_of_range& e) {
27432       {
27433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27434       };
27435     } catch (std::exception& e) {
27436       {
27437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27438       };
27439     } catch (...) {
27440       {
27441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27442       };
27443     }
27444   }
27445   jresult = result;
27446   return jresult;
27447 }
27448
27449
27450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27451   unsigned int jresult ;
27452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27453   bool result;
27454
27455   arg1 = (Dali::KeyEvent *)jarg1;
27456   {
27457     try {
27458       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27459     } catch (std::out_of_range& e) {
27460       {
27461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27462       };
27463     } catch (std::exception& e) {
27464       {
27465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27466       };
27467     } catch (...) {
27468       {
27469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27470       };
27471     }
27472   }
27473   jresult = result;
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27479   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27480   std::string *arg2 = 0 ;
27481
27482   arg1 = (Dali::KeyEvent *)jarg1;
27483   if (!jarg2) {
27484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27485     return ;
27486   }
27487   std::string arg2_str(jarg2);
27488   arg2 = &arg2_str;
27489   if (arg1) (arg1)->keyPressedName = *arg2;
27490
27491   //argout typemap for const std::string&
27492
27493 }
27494
27495
27496 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27497   char * jresult ;
27498   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27499   std::string *result = 0 ;
27500
27501   arg1 = (Dali::KeyEvent *)jarg1;
27502   result = (std::string *) & ((arg1)->keyPressedName);
27503   jresult = SWIG_csharp_string_callback(result->c_str());
27504   return jresult;
27505 }
27506
27507
27508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27509   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27510   std::string *arg2 = 0 ;
27511
27512   arg1 = (Dali::KeyEvent *)jarg1;
27513   if (!jarg2) {
27514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27515     return ;
27516   }
27517   std::string arg2_str(jarg2);
27518   arg2 = &arg2_str;
27519   if (arg1) (arg1)->keyPressed = *arg2;
27520
27521   //argout typemap for const std::string&
27522
27523 }
27524
27525
27526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27527   char * jresult ;
27528   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27529   std::string *result = 0 ;
27530
27531   arg1 = (Dali::KeyEvent *)jarg1;
27532   result = (std::string *) & ((arg1)->keyPressed);
27533   jresult = SWIG_csharp_string_callback(result->c_str());
27534   return jresult;
27535 }
27536
27537
27538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27539   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27540   int arg2 ;
27541
27542   arg1 = (Dali::KeyEvent *)jarg1;
27543   arg2 = (int)jarg2;
27544   if (arg1) (arg1)->keyCode = arg2;
27545 }
27546
27547
27548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27549   int jresult ;
27550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27551   int result;
27552
27553   arg1 = (Dali::KeyEvent *)jarg1;
27554   result = (int) ((arg1)->keyCode);
27555   jresult = result;
27556   return jresult;
27557 }
27558
27559
27560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27561   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27562   int arg2 ;
27563
27564   arg1 = (Dali::KeyEvent *)jarg1;
27565   arg2 = (int)jarg2;
27566   if (arg1) (arg1)->keyModifier = arg2;
27567 }
27568
27569
27570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27571   int jresult ;
27572   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27573   int result;
27574
27575   arg1 = (Dali::KeyEvent *)jarg1;
27576   result = (int) ((arg1)->keyModifier);
27577   jresult = result;
27578   return jresult;
27579 }
27580
27581
27582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27584   unsigned long arg2 ;
27585
27586   arg1 = (Dali::KeyEvent *)jarg1;
27587   arg2 = (unsigned long)jarg2;
27588   if (arg1) (arg1)->time = arg2;
27589 }
27590
27591
27592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27593   unsigned long jresult ;
27594   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27595   unsigned long result;
27596
27597   arg1 = (Dali::KeyEvent *)jarg1;
27598   result = (unsigned long) ((arg1)->time);
27599   jresult = (unsigned long)result;
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27605   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27606   Dali::KeyEvent::State arg2 ;
27607
27608   arg1 = (Dali::KeyEvent *)jarg1;
27609   arg2 = (Dali::KeyEvent::State)jarg2;
27610   if (arg1) (arg1)->state = arg2;
27611 }
27612
27613
27614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27615   int jresult ;
27616   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27617   Dali::KeyEvent::State result;
27618
27619   arg1 = (Dali::KeyEvent *)jarg1;
27620   result = (Dali::KeyEvent::State) ((arg1)->state);
27621   jresult = (int)result;
27622   return jresult;
27623 }
27624
27625
27626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27627   void * jresult ;
27628   Dali::LongPressGestureDetector *result = 0 ;
27629
27630   {
27631     try {
27632       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27633     } catch (std::out_of_range& e) {
27634       {
27635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27636       };
27637     } catch (std::exception& e) {
27638       {
27639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27640       };
27641     } catch (...) {
27642       {
27643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27644       };
27645     }
27646   }
27647   jresult = (void *)result;
27648   return jresult;
27649 }
27650
27651
27652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27653   void * jresult ;
27654   Dali::LongPressGestureDetector result;
27655
27656   {
27657     try {
27658       result = Dali::LongPressGestureDetector::New();
27659     } catch (std::out_of_range& e) {
27660       {
27661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27662       };
27663     } catch (std::exception& e) {
27664       {
27665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27666       };
27667     } catch (...) {
27668       {
27669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27670       };
27671     }
27672   }
27673   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27674   return jresult;
27675 }
27676
27677
27678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27679   void * jresult ;
27680   unsigned int arg1 ;
27681   Dali::LongPressGestureDetector result;
27682
27683   arg1 = (unsigned int)jarg1;
27684   {
27685     try {
27686       result = Dali::LongPressGestureDetector::New(arg1);
27687     } catch (std::out_of_range& e) {
27688       {
27689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27690       };
27691     } catch (std::exception& e) {
27692       {
27693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27694       };
27695     } catch (...) {
27696       {
27697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27698       };
27699     }
27700   }
27701   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27702   return jresult;
27703 }
27704
27705
27706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27707   void * jresult ;
27708   unsigned int arg1 ;
27709   unsigned int arg2 ;
27710   Dali::LongPressGestureDetector result;
27711
27712   arg1 = (unsigned int)jarg1;
27713   arg2 = (unsigned int)jarg2;
27714   {
27715     try {
27716       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27717     } catch (std::out_of_range& e) {
27718       {
27719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27720       };
27721     } catch (std::exception& e) {
27722       {
27723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27724       };
27725     } catch (...) {
27726       {
27727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27728       };
27729     }
27730   }
27731   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27732   return jresult;
27733 }
27734
27735
27736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27737   void * jresult ;
27738   Dali::BaseHandle arg1 ;
27739   Dali::BaseHandle *argp1 ;
27740   Dali::LongPressGestureDetector result;
27741
27742   argp1 = (Dali::BaseHandle *)jarg1;
27743   if (!argp1) {
27744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27745     return 0;
27746   }
27747   arg1 = *argp1;
27748   {
27749     try {
27750       result = Dali::LongPressGestureDetector::DownCast(arg1);
27751     } catch (std::out_of_range& e) {
27752       {
27753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27754       };
27755     } catch (std::exception& e) {
27756       {
27757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27758       };
27759     } catch (...) {
27760       {
27761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27762       };
27763     }
27764   }
27765   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27766   return jresult;
27767 }
27768
27769
27770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27771   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27772
27773   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27774   {
27775     try {
27776       delete arg1;
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27784       };
27785     } catch (...) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27788       };
27789     }
27790   }
27791 }
27792
27793
27794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27795   void * jresult ;
27796   Dali::LongPressGestureDetector *arg1 = 0 ;
27797   Dali::LongPressGestureDetector *result = 0 ;
27798
27799   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27800   if (!arg1) {
27801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27802     return 0;
27803   }
27804   {
27805     try {
27806       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27807     } catch (std::out_of_range& e) {
27808       {
27809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27810       };
27811     } catch (std::exception& e) {
27812       {
27813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27814       };
27815     } catch (...) {
27816       {
27817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27818       };
27819     }
27820   }
27821   jresult = (void *)result;
27822   return jresult;
27823 }
27824
27825
27826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27827   void * jresult ;
27828   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27829   Dali::LongPressGestureDetector *arg2 = 0 ;
27830   Dali::LongPressGestureDetector *result = 0 ;
27831
27832   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27833   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27834   if (!arg2) {
27835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27836     return 0;
27837   }
27838   {
27839     try {
27840       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27841     } catch (std::out_of_range& e) {
27842       {
27843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27844       };
27845     } catch (std::exception& e) {
27846       {
27847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (...) {
27850       {
27851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27852       };
27853     }
27854   }
27855   jresult = (void *)result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27862   unsigned int arg2 ;
27863
27864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27865   arg2 = (unsigned int)jarg2;
27866   {
27867     try {
27868       (arg1)->SetTouchesRequired(arg2);
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27876       };
27877     } catch (...) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27880       };
27881     }
27882   }
27883 }
27884
27885
27886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27887   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27888   unsigned int arg2 ;
27889   unsigned int arg3 ;
27890
27891   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27892   arg2 = (unsigned int)jarg2;
27893   arg3 = (unsigned int)jarg3;
27894   {
27895     try {
27896       (arg1)->SetTouchesRequired(arg2,arg3);
27897     } catch (std::out_of_range& e) {
27898       {
27899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27900       };
27901     } catch (std::exception& e) {
27902       {
27903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27904       };
27905     } catch (...) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27908       };
27909     }
27910   }
27911 }
27912
27913
27914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27915   unsigned int jresult ;
27916   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27917   unsigned int result;
27918
27919   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27920   {
27921     try {
27922       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27923     } catch (std::out_of_range& e) {
27924       {
27925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (std::exception& e) {
27928       {
27929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (...) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27934       };
27935     }
27936   }
27937   jresult = result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27943   unsigned int jresult ;
27944   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27945   unsigned int result;
27946
27947   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27948   {
27949     try {
27950       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27951     } catch (std::out_of_range& e) {
27952       {
27953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27954       };
27955     } catch (std::exception& e) {
27956       {
27957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27958       };
27959     } catch (...) {
27960       {
27961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27962       };
27963     }
27964   }
27965   jresult = result;
27966   return jresult;
27967 }
27968
27969
27970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27971   void * jresult ;
27972   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27973   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27974
27975   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27976   {
27977     try {
27978       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27979     } catch (std::out_of_range& e) {
27980       {
27981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27982       };
27983     } catch (std::exception& e) {
27984       {
27985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27986       };
27987     } catch (...) {
27988       {
27989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27990       };
27991     }
27992   }
27993   jresult = (void *)result;
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27999   void * jresult ;
28000   Dali::Gesture::State arg1 ;
28001   Dali::LongPressGesture *result = 0 ;
28002
28003   arg1 = (Dali::Gesture::State)jarg1;
28004   {
28005     try {
28006       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
28007     } catch (std::out_of_range& e) {
28008       {
28009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28010       };
28011     } catch (std::exception& e) {
28012       {
28013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (...) {
28016       {
28017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28018       };
28019     }
28020   }
28021   jresult = (void *)result;
28022   return jresult;
28023 }
28024
28025
28026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28027   void * jresult ;
28028   Dali::LongPressGesture *arg1 = 0 ;
28029   Dali::LongPressGesture *result = 0 ;
28030
28031   arg1 = (Dali::LongPressGesture *)jarg1;
28032   if (!arg1) {
28033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28034     return 0;
28035   }
28036   {
28037     try {
28038       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28039     } catch (std::out_of_range& e) {
28040       {
28041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28042       };
28043     } catch (std::exception& e) {
28044       {
28045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28046       };
28047     } catch (...) {
28048       {
28049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28050       };
28051     }
28052   }
28053   jresult = (void *)result;
28054   return jresult;
28055 }
28056
28057
28058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28059   void * jresult ;
28060   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28061   Dali::LongPressGesture *arg2 = 0 ;
28062   Dali::LongPressGesture *result = 0 ;
28063
28064   arg1 = (Dali::LongPressGesture *)jarg1;
28065   arg2 = (Dali::LongPressGesture *)jarg2;
28066   if (!arg2) {
28067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28068     return 0;
28069   }
28070   {
28071     try {
28072       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28073     } catch (std::out_of_range& e) {
28074       {
28075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28076       };
28077     } catch (std::exception& e) {
28078       {
28079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28080       };
28081     } catch (...) {
28082       {
28083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28084       };
28085     }
28086   }
28087   jresult = (void *)result;
28088   return jresult;
28089 }
28090
28091
28092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28094
28095   arg1 = (Dali::LongPressGesture *)jarg1;
28096   {
28097     try {
28098       delete arg1;
28099     } catch (std::out_of_range& e) {
28100       {
28101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28102       };
28103     } catch (std::exception& e) {
28104       {
28105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28106       };
28107     } catch (...) {
28108       {
28109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28110       };
28111     }
28112   }
28113 }
28114
28115
28116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28117   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28118   unsigned int arg2 ;
28119
28120   arg1 = (Dali::LongPressGesture *)jarg1;
28121   arg2 = (unsigned int)jarg2;
28122   if (arg1) (arg1)->numberOfTouches = arg2;
28123 }
28124
28125
28126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28127   unsigned int jresult ;
28128   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28129   unsigned int result;
28130
28131   arg1 = (Dali::LongPressGesture *)jarg1;
28132   result = (unsigned int) ((arg1)->numberOfTouches);
28133   jresult = result;
28134   return jresult;
28135 }
28136
28137
28138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28139   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28140   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28141
28142   arg1 = (Dali::LongPressGesture *)jarg1;
28143   arg2 = (Dali::Vector2 *)jarg2;
28144   if (arg1) (arg1)->screenPoint = *arg2;
28145 }
28146
28147
28148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28149   void * jresult ;
28150   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28151   Dali::Vector2 *result = 0 ;
28152
28153   arg1 = (Dali::LongPressGesture *)jarg1;
28154   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28155   jresult = (void *)result;
28156   return jresult;
28157 }
28158
28159
28160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28161   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28162   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28163
28164   arg1 = (Dali::LongPressGesture *)jarg1;
28165   arg2 = (Dali::Vector2 *)jarg2;
28166   if (arg1) (arg1)->localPoint = *arg2;
28167 }
28168
28169
28170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28171   void * jresult ;
28172   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28173   Dali::Vector2 *result = 0 ;
28174
28175   arg1 = (Dali::LongPressGesture *)jarg1;
28176   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28177   jresult = (void *)result;
28178   return jresult;
28179 }
28180
28181
28182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28183   void * jresult ;
28184   Dali::WheelEvent *result = 0 ;
28185
28186   {
28187     try {
28188       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28189     } catch (std::out_of_range& e) {
28190       {
28191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28192       };
28193     } catch (std::exception& e) {
28194       {
28195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28196       };
28197     } catch (...) {
28198       {
28199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28200       };
28201     }
28202   }
28203   jresult = (void *)result;
28204   return jresult;
28205 }
28206
28207
28208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28209   void * jresult ;
28210   Dali::WheelEvent::Type arg1 ;
28211   int arg2 ;
28212   unsigned int arg3 ;
28213   Dali::Vector2 arg4 ;
28214   int arg5 ;
28215   unsigned int arg6 ;
28216   Dali::Vector2 *argp4 ;
28217   Dali::WheelEvent *result = 0 ;
28218
28219   arg1 = (Dali::WheelEvent::Type)jarg1;
28220   arg2 = (int)jarg2;
28221   arg3 = (unsigned int)jarg3;
28222   argp4 = (Dali::Vector2 *)jarg4;
28223   if (!argp4) {
28224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28225     return 0;
28226   }
28227   arg4 = *argp4;
28228   arg5 = (int)jarg5;
28229   arg6 = (unsigned int)jarg6;
28230   {
28231     try {
28232       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28233     } catch (std::out_of_range& e) {
28234       {
28235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28236       };
28237     } catch (std::exception& e) {
28238       {
28239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28240       };
28241     } catch (...) {
28242       {
28243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28244       };
28245     }
28246   }
28247   jresult = (void *)result;
28248   return jresult;
28249 }
28250
28251
28252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28254
28255   arg1 = (Dali::WheelEvent *)jarg1;
28256   {
28257     try {
28258       delete arg1;
28259     } catch (std::out_of_range& e) {
28260       {
28261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28262       };
28263     } catch (std::exception& e) {
28264       {
28265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28266       };
28267     } catch (...) {
28268       {
28269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28270       };
28271     }
28272   }
28273 }
28274
28275
28276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28277   unsigned int jresult ;
28278   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28279   bool result;
28280
28281   arg1 = (Dali::WheelEvent *)jarg1;
28282   {
28283     try {
28284       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28285     } catch (std::out_of_range& e) {
28286       {
28287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28288       };
28289     } catch (std::exception& e) {
28290       {
28291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28292       };
28293     } catch (...) {
28294       {
28295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28296       };
28297     }
28298   }
28299   jresult = result;
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28305   unsigned int jresult ;
28306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28307   bool result;
28308
28309   arg1 = (Dali::WheelEvent *)jarg1;
28310   {
28311     try {
28312       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28320       };
28321     } catch (...) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28324       };
28325     }
28326   }
28327   jresult = result;
28328   return jresult;
28329 }
28330
28331
28332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28333   unsigned int jresult ;
28334   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28335   bool result;
28336
28337   arg1 = (Dali::WheelEvent *)jarg1;
28338   {
28339     try {
28340       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28341     } catch (std::out_of_range& e) {
28342       {
28343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28344       };
28345     } catch (std::exception& e) {
28346       {
28347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28348       };
28349     } catch (...) {
28350       {
28351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28352       };
28353     }
28354   }
28355   jresult = result;
28356   return jresult;
28357 }
28358
28359
28360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   Dali::WheelEvent::Type arg2 ;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   arg2 = (Dali::WheelEvent::Type)jarg2;
28366   if (arg1) (arg1)->type = arg2;
28367 }
28368
28369
28370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28371   int jresult ;
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   Dali::WheelEvent::Type result;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   result = (Dali::WheelEvent::Type) ((arg1)->type);
28377   jresult = (int)result;
28378   return jresult;
28379 }
28380
28381
28382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   int arg2 ;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   arg2 = (int)jarg2;
28388   if (arg1) (arg1)->direction = arg2;
28389 }
28390
28391
28392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28393   int jresult ;
28394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28395   int result;
28396
28397   arg1 = (Dali::WheelEvent *)jarg1;
28398   result = (int) ((arg1)->direction);
28399   jresult = result;
28400   return jresult;
28401 }
28402
28403
28404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28406   unsigned int arg2 ;
28407
28408   arg1 = (Dali::WheelEvent *)jarg1;
28409   arg2 = (unsigned int)jarg2;
28410   if (arg1) (arg1)->modifiers = arg2;
28411 }
28412
28413
28414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28415   unsigned int jresult ;
28416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28417   unsigned int result;
28418
28419   arg1 = (Dali::WheelEvent *)jarg1;
28420   result = (unsigned int) ((arg1)->modifiers);
28421   jresult = result;
28422   return jresult;
28423 }
28424
28425
28426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28428   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28429
28430   arg1 = (Dali::WheelEvent *)jarg1;
28431   arg2 = (Dali::Vector2 *)jarg2;
28432   if (arg1) (arg1)->point = *arg2;
28433 }
28434
28435
28436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28437   void * jresult ;
28438   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28439   Dali::Vector2 *result = 0 ;
28440
28441   arg1 = (Dali::WheelEvent *)jarg1;
28442   result = (Dali::Vector2 *)& ((arg1)->point);
28443   jresult = (void *)result;
28444   return jresult;
28445 }
28446
28447
28448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28449   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28450   int arg2 ;
28451
28452   arg1 = (Dali::WheelEvent *)jarg1;
28453   arg2 = (int)jarg2;
28454   if (arg1) (arg1)->z = arg2;
28455 }
28456
28457
28458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28459   int jresult ;
28460   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28461   int result;
28462
28463   arg1 = (Dali::WheelEvent *)jarg1;
28464   result = (int) ((arg1)->z);
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28471   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28472   unsigned int arg2 ;
28473
28474   arg1 = (Dali::WheelEvent *)jarg1;
28475   arg2 = (unsigned int)jarg2;
28476   if (arg1) (arg1)->timeStamp = arg2;
28477 }
28478
28479
28480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28481   unsigned int jresult ;
28482   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28483   unsigned int result;
28484
28485   arg1 = (Dali::WheelEvent *)jarg1;
28486   result = (unsigned int) ((arg1)->timeStamp);
28487   jresult = result;
28488   return jresult;
28489 }
28490
28491 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28492   char * jresult ;
28493   Dali::KeyEvent *arg1 = 0 ;
28494   std::string result;
28495
28496   arg1 = (Dali::KeyEvent *)jarg1;
28497   if (!arg1) {
28498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28499     return 0;
28500   }
28501   {
28502     try {
28503       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28504     } catch (std::out_of_range& e) {
28505       {
28506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28507       };
28508     } catch (std::exception& e) {
28509       {
28510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28511       };
28512     } catch (...) {
28513       {
28514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28515       };
28516     }
28517   }
28518   jresult = SWIG_csharp_string_callback((&result)->c_str());
28519   return jresult;
28520 }
28521
28522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28523   int jresult ;
28524   Dali::KeyEvent *arg1 = 0 ;
28525   Dali::DevelKeyEvent::DeviceClass::Type result;
28526
28527   arg1 = (Dali::KeyEvent *)jarg1;
28528   if (!arg1) {
28529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28530     return 0;
28531   }
28532   {
28533     try {
28534       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28535     } catch (std::out_of_range& e) {
28536       {
28537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28538       };
28539     } catch (std::exception& e) {
28540       {
28541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28542       };
28543     } catch (...) {
28544       {
28545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28546       };
28547     }
28548   }
28549   jresult = (int)result;
28550   return jresult;
28551 }
28552
28553
28554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28555   Dali::Actor arg1 ;
28556   Dali::Actor *argp1 ;
28557
28558   argp1 = (Dali::Actor *)jarg1;
28559   if (!argp1) {
28560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28561     return ;
28562   }
28563   arg1 = *argp1;
28564   {
28565     try {
28566       Dali::DevelActor::Raise(arg1);
28567     } catch (std::out_of_range& e) {
28568       {
28569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28570       };
28571     } catch (std::exception& e) {
28572       {
28573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28574       };
28575     } catch (...) {
28576       {
28577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28578       };
28579     }
28580   }
28581 }
28582
28583
28584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28585   Dali::Actor arg1 ;
28586   Dali::Actor *argp1 ;
28587
28588   argp1 = (Dali::Actor *)jarg1;
28589   if (!argp1) {
28590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28591     return ;
28592   }
28593   arg1 = *argp1;
28594   {
28595     try {
28596       Dali::DevelActor::Lower(arg1);
28597     } catch (std::out_of_range& e) {
28598       {
28599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28600       };
28601     } catch (std::exception& e) {
28602       {
28603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28604       };
28605     } catch (...) {
28606       {
28607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28608       };
28609     }
28610   }
28611 }
28612
28613
28614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28615   Dali::Actor arg1 ;
28616   Dali::Actor *argp1 ;
28617
28618   argp1 = (Dali::Actor *)jarg1;
28619   if (!argp1) {
28620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28621     return ;
28622   }
28623   arg1 = *argp1;
28624   {
28625     try {
28626       Dali::DevelActor::RaiseToTop(arg1);
28627     } catch (std::out_of_range& e) {
28628       {
28629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28630       };
28631     } catch (std::exception& e) {
28632       {
28633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28634       };
28635     } catch (...) {
28636       {
28637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28638       };
28639     }
28640   }
28641 }
28642
28643
28644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28645   Dali::Actor arg1 ;
28646   Dali::Actor *argp1 ;
28647
28648   argp1 = (Dali::Actor *)jarg1;
28649   if (!argp1) {
28650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28651     return ;
28652   }
28653   arg1 = *argp1;
28654   {
28655     try {
28656       Dali::DevelActor::LowerToBottom(arg1);
28657     } catch (std::out_of_range& e) {
28658       {
28659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28660       };
28661     } catch (std::exception& e) {
28662       {
28663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28664       };
28665     } catch (...) {
28666       {
28667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28668       };
28669     }
28670   }
28671 }
28672
28673
28674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28675   Dali::Actor arg1 ;
28676   Dali::Actor arg2 ;
28677   Dali::Actor *argp1 ;
28678   Dali::Actor *argp2 ;
28679
28680   argp1 = (Dali::Actor *)jarg1;
28681   if (!argp1) {
28682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28683     return ;
28684   }
28685   arg1 = *argp1;
28686   argp2 = (Dali::Actor *)jarg2;
28687   if (!argp2) {
28688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28689     return ;
28690   }
28691   arg2 = *argp2;
28692   {
28693     try {
28694       Dali::DevelActor::RaiseAbove(arg1,arg2);
28695     } catch (std::out_of_range& e) {
28696       {
28697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28698       };
28699     } catch (std::exception& e) {
28700       {
28701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28702       };
28703     } catch (...) {
28704       {
28705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28706       };
28707     }
28708   }
28709 }
28710
28711
28712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28713   Dali::Actor arg1 ;
28714   Dali::Actor arg2 ;
28715   Dali::Actor *argp1 ;
28716   Dali::Actor *argp2 ;
28717
28718   argp1 = (Dali::Actor *)jarg1;
28719   if (!argp1) {
28720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28721     return ;
28722   }
28723   arg1 = *argp1;
28724   argp2 = (Dali::Actor *)jarg2;
28725   if (!argp2) {
28726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28727     return ;
28728   }
28729   arg2 = *argp2;
28730   {
28731     try {
28732       Dali::DevelActor::LowerBelow(arg1,arg2);
28733     } catch (std::out_of_range& e) {
28734       {
28735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28736       };
28737     } catch (std::exception& e) {
28738       {
28739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28740       };
28741     } catch (...) {
28742       {
28743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28744       };
28745     }
28746   }
28747 }
28748
28749
28750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28751   void * jresult ;
28752   Dali::Actor arg1 ;
28753   Dali::Actor *argp1 ;
28754   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28755
28756   argp1 = (Dali::Actor *)jarg1;
28757   if (!argp1) {
28758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28759     return 0;
28760   }
28761   arg1 = *argp1;
28762   {
28763     try {
28764       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28765     } catch (std::out_of_range& e) {
28766       {
28767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28768       };
28769     } catch (std::exception& e) {
28770       {
28771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28772       };
28773     } catch (...) {
28774       {
28775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28776       };
28777     }
28778   }
28779   jresult = (void *)result;
28780   return jresult;
28781 }
28782
28783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28784   int jresult ;
28785   int result;
28786
28787   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28788   jresult = (int)result;
28789   return jresult;
28790 }
28791
28792
28793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28794   int jresult ;
28795   int result;
28796
28797   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28798   jresult = (int)result;
28799   return jresult;
28800 }
28801
28802
28803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28804   int jresult ;
28805   int result;
28806
28807   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28808   jresult = (int)result;
28809   return jresult;
28810 }
28811
28812
28813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28814   int jresult ;
28815   int result;
28816
28817   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28818   jresult = (int)result;
28819   return jresult;
28820 }
28821
28822
28823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28824   int jresult ;
28825   int result;
28826
28827   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28828   jresult = (int)result;
28829   return jresult;
28830 }
28831
28832
28833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28834   int jresult ;
28835   int result;
28836
28837   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28838   jresult = (int)result;
28839   return jresult;
28840 }
28841
28842
28843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28844   int jresult ;
28845   int result;
28846
28847   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28848   jresult = (int)result;
28849   return jresult;
28850 }
28851
28852
28853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28854   int jresult ;
28855   int result;
28856
28857   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28858   jresult = (int)result;
28859   return jresult;
28860 }
28861
28862
28863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28864   int jresult ;
28865   int result;
28866
28867   result = (int)Dali::Actor::Property::SIZE;
28868   jresult = (int)result;
28869   return jresult;
28870 }
28871
28872
28873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28874   int jresult ;
28875   int result;
28876
28877   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28878   jresult = (int)result;
28879   return jresult;
28880 }
28881
28882
28883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28884   int jresult ;
28885   int result;
28886
28887   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28888   jresult = (int)result;
28889   return jresult;
28890 }
28891
28892
28893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28894   int jresult ;
28895   int result;
28896
28897   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28898   jresult = (int)result;
28899   return jresult;
28900 }
28901
28902
28903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28904   int jresult ;
28905   int result;
28906
28907   result = (int)Dali::Actor::Property::POSITION;
28908   jresult = (int)result;
28909   return jresult;
28910 }
28911
28912
28913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28914   int jresult ;
28915   int result;
28916
28917   result = (int)Dali::Actor::Property::POSITION_X;
28918   jresult = (int)result;
28919   return jresult;
28920 }
28921
28922
28923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28924   int jresult ;
28925   int result;
28926
28927   result = (int)Dali::Actor::Property::POSITION_Y;
28928   jresult = (int)result;
28929   return jresult;
28930 }
28931
28932
28933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28934   int jresult ;
28935   int result;
28936
28937   result = (int)Dali::Actor::Property::POSITION_Z;
28938   jresult = (int)result;
28939   return jresult;
28940 }
28941
28942
28943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28944   int jresult ;
28945   int result;
28946
28947   result = (int)Dali::Actor::Property::WORLD_POSITION;
28948   jresult = (int)result;
28949   return jresult;
28950 }
28951
28952
28953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28954   int jresult ;
28955   int result;
28956
28957   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28958   jresult = (int)result;
28959   return jresult;
28960 }
28961
28962
28963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28964   int jresult ;
28965   int result;
28966
28967   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28968   jresult = (int)result;
28969   return jresult;
28970 }
28971
28972
28973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28974   int jresult ;
28975   int result;
28976
28977   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28978   jresult = (int)result;
28979   return jresult;
28980 }
28981
28982
28983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28984   int jresult ;
28985   int result;
28986
28987   result = (int)Dali::Actor::Property::ORIENTATION;
28988   jresult = (int)result;
28989   return jresult;
28990 }
28991
28992
28993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28994   int jresult ;
28995   int result;
28996
28997   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28998   jresult = (int)result;
28999   return jresult;
29000 }
29001
29002
29003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
29004   int jresult ;
29005   int result;
29006
29007   result = (int)Dali::Actor::Property::SCALE;
29008   jresult = (int)result;
29009   return jresult;
29010 }
29011
29012
29013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
29014   int jresult ;
29015   int result;
29016
29017   result = (int)Dali::Actor::Property::SCALE_X;
29018   jresult = (int)result;
29019   return jresult;
29020 }
29021
29022
29023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
29024   int jresult ;
29025   int result;
29026
29027   result = (int)Dali::Actor::Property::SCALE_Y;
29028   jresult = (int)result;
29029   return jresult;
29030 }
29031
29032
29033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
29034   int jresult ;
29035   int result;
29036
29037   result = (int)Dali::Actor::Property::SCALE_Z;
29038   jresult = (int)result;
29039   return jresult;
29040 }
29041
29042
29043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
29044   int jresult ;
29045   int result;
29046
29047   result = (int)Dali::Actor::Property::WORLD_SCALE;
29048   jresult = (int)result;
29049   return jresult;
29050 }
29051
29052
29053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
29054   int jresult ;
29055   int result;
29056
29057   result = (int)Dali::Actor::Property::VISIBLE;
29058   jresult = (int)result;
29059   return jresult;
29060 }
29061
29062
29063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
29064   int jresult ;
29065   int result;
29066
29067   result = (int)Dali::Actor::Property::COLOR;
29068   jresult = (int)result;
29069   return jresult;
29070 }
29071
29072
29073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
29074   int jresult ;
29075   int result;
29076
29077   result = (int)Dali::Actor::Property::COLOR_RED;
29078   jresult = (int)result;
29079   return jresult;
29080 }
29081
29082
29083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29084   int jresult ;
29085   int result;
29086
29087   result = (int)Dali::Actor::Property::COLOR_GREEN;
29088   jresult = (int)result;
29089   return jresult;
29090 }
29091
29092
29093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29094   int jresult ;
29095   int result;
29096
29097   result = (int)Dali::Actor::Property::COLOR_BLUE;
29098   jresult = (int)result;
29099   return jresult;
29100 }
29101
29102
29103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29104   int jresult ;
29105   int result;
29106
29107   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29108   jresult = (int)result;
29109   return jresult;
29110 }
29111
29112
29113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29114   int jresult ;
29115   int result;
29116
29117   result = (int)Dali::Actor::Property::WORLD_COLOR;
29118   jresult = (int)result;
29119   return jresult;
29120 }
29121
29122
29123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29124   int jresult ;
29125   int result;
29126
29127   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29128   jresult = (int)result;
29129   return jresult;
29130 }
29131
29132
29133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29134   int jresult ;
29135   int result;
29136
29137   result = (int)Dali::Actor::Property::NAME;
29138   jresult = (int)result;
29139   return jresult;
29140 }
29141
29142
29143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29144   int jresult ;
29145   int result;
29146
29147   result = (int)Dali::Actor::Property::SENSITIVE;
29148   jresult = (int)result;
29149   return jresult;
29150 }
29151
29152
29153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29154   int jresult ;
29155   int result;
29156
29157   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29158   jresult = (int)result;
29159   return jresult;
29160 }
29161
29162
29163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29164   int jresult ;
29165   int result;
29166
29167   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29168   jresult = (int)result;
29169   return jresult;
29170 }
29171
29172
29173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29174   int jresult ;
29175   int result;
29176
29177   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29178   jresult = (int)result;
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29184   int jresult ;
29185   int result;
29186
29187   result = (int)Dali::Actor::Property::COLOR_MODE;
29188   jresult = (int)result;
29189   return jresult;
29190 }
29191
29192
29193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29194   int jresult ;
29195   int result;
29196
29197   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29198   jresult = (int)result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29204   int jresult ;
29205   int result;
29206
29207   result = (int)Dali::Actor::Property::DRAW_MODE;
29208   jresult = (int)result;
29209   return jresult;
29210 }
29211
29212
29213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29214   int jresult ;
29215   int result;
29216
29217   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29218   jresult = (int)result;
29219   return jresult;
29220 }
29221
29222
29223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29224   int jresult ;
29225   int result;
29226
29227   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29228   jresult = (int)result;
29229   return jresult;
29230 }
29231
29232
29233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29234   int jresult ;
29235   int result;
29236
29237   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29238   jresult = (int)result;
29239   return jresult;
29240 }
29241
29242
29243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29244   int jresult ;
29245   int result;
29246
29247   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29248   jresult = (int)result;
29249   return jresult;
29250 }
29251
29252
29253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29254   int jresult ;
29255   int result;
29256
29257   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29258   jresult = (int)result;
29259   return jresult;
29260 }
29261
29262
29263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29264   int jresult ;
29265   int result;
29266
29267   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29268   jresult = (int)result;
29269   return jresult;
29270 }
29271
29272
29273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29274   int jresult ;
29275   int result;
29276
29277   result = (int)Dali::Actor::Property::PADDING;
29278   jresult = (int)result;
29279   return jresult;
29280 }
29281
29282
29283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29284   int jresult ;
29285   int result;
29286
29287   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29288   jresult = (int)result;
29289   return jresult;
29290 }
29291
29292
29293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29294   int jresult ;
29295   int result;
29296
29297   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29298   jresult = (int)result;
29299   return jresult;
29300 }
29301
29302
29303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29304   int jresult ;
29305   int result;
29306
29307   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29308   jresult = (int)result;
29309   return jresult;
29310 }
29311
29312
29313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29314   int jresult ;
29315   int result;
29316
29317   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29318   jresult = (int)result;
29319   return jresult;
29320 }
29321
29322
29323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29324   void * jresult ;
29325   Dali::Actor::Property *result = 0 ;
29326
29327   {
29328     try {
29329       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29330     } catch (std::out_of_range& e) {
29331       {
29332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29333       };
29334     } catch (std::exception& e) {
29335       {
29336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29337       };
29338     } catch (...) {
29339       {
29340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29341       };
29342     }
29343   }
29344   jresult = (void *)result;
29345   return jresult;
29346 }
29347
29348
29349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29350   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29351
29352   arg1 = (Dali::Actor::Property *)jarg1;
29353   {
29354     try {
29355       delete arg1;
29356     } catch (std::out_of_range& e) {
29357       {
29358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29359       };
29360     } catch (std::exception& e) {
29361       {
29362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29363       };
29364     } catch (...) {
29365       {
29366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29367       };
29368     }
29369   }
29370 }
29371
29372
29373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29374   void * jresult ;
29375   Dali::Actor *result = 0 ;
29376
29377   {
29378     try {
29379       result = (Dali::Actor *)new Dali::Actor();
29380     } catch (std::out_of_range& e) {
29381       {
29382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29383       };
29384     } catch (std::exception& e) {
29385       {
29386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (...) {
29389       {
29390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29391       };
29392     }
29393   }
29394   jresult = (void *)result;
29395   return jresult;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29400   void * jresult ;
29401   Dali::Actor result;
29402
29403   {
29404     try {
29405       result = Dali::Actor::New();
29406     } catch (std::out_of_range& e) {
29407       {
29408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29409       };
29410     } catch (std::exception& e) {
29411       {
29412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29413       };
29414     } catch (...) {
29415       {
29416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29417       };
29418     }
29419   }
29420   jresult = new Dali::Actor((const Dali::Actor &)result);
29421   return jresult;
29422 }
29423
29424
29425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29426   void * jresult ;
29427   Dali::BaseHandle arg1 ;
29428   Dali::BaseHandle *argp1 ;
29429   Dali::Actor result;
29430
29431   argp1 = (Dali::BaseHandle *)jarg1;
29432   if (!argp1) {
29433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29434     return 0;
29435   }
29436   arg1 = *argp1;
29437   {
29438     try {
29439       result = Dali::Actor::DownCast(arg1);
29440     } catch (std::out_of_range& e) {
29441       {
29442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29443       };
29444     } catch (std::exception& e) {
29445       {
29446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29447       };
29448     } catch (...) {
29449       {
29450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29451       };
29452     }
29453   }
29454   jresult = new Dali::Actor((const Dali::Actor &)result);
29455   return jresult;
29456 }
29457
29458
29459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29461
29462   arg1 = (Dali::Actor *)jarg1;
29463   {
29464     try {
29465       delete arg1;
29466     } catch (std::out_of_range& e) {
29467       {
29468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29469       };
29470     } catch (std::exception& e) {
29471       {
29472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29473       };
29474     } catch (...) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29477       };
29478     }
29479   }
29480 }
29481
29482
29483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29484   void * jresult ;
29485   Dali::Actor *arg1 = 0 ;
29486   Dali::Actor *result = 0 ;
29487
29488   arg1 = (Dali::Actor *)jarg1;
29489   if (!arg1) {
29490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29491     return 0;
29492   }
29493   {
29494     try {
29495       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29496     } catch (std::out_of_range& e) {
29497       {
29498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29499       };
29500     } catch (std::exception& e) {
29501       {
29502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29503       };
29504     } catch (...) {
29505       {
29506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29507       };
29508     }
29509   }
29510   jresult = (void *)result;
29511   return jresult;
29512 }
29513
29514
29515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29516   void * jresult ;
29517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29518   Dali::Actor *arg2 = 0 ;
29519   Dali::Actor *result = 0 ;
29520
29521   arg1 = (Dali::Actor *)jarg1;
29522   arg2 = (Dali::Actor *)jarg2;
29523   if (!arg2) {
29524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29525     return 0;
29526   }
29527   {
29528     try {
29529       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29530     } catch (std::out_of_range& e) {
29531       {
29532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29533       };
29534     } catch (std::exception& e) {
29535       {
29536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (...) {
29539       {
29540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29541       };
29542     }
29543   }
29544   jresult = (void *)result;
29545   return jresult;
29546 }
29547
29548
29549 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29550   char * jresult ;
29551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29552   std::string *result = 0 ;
29553
29554   arg1 = (Dali::Actor *)jarg1;
29555   {
29556     try {
29557       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29558     } catch (std::out_of_range& e) {
29559       {
29560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29561       };
29562     } catch (std::exception& e) {
29563       {
29564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29565       };
29566     } catch (...) {
29567       {
29568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29569       };
29570     }
29571   }
29572   jresult = SWIG_csharp_string_callback(result->c_str());
29573   return jresult;
29574 }
29575
29576
29577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29579   std::string *arg2 = 0 ;
29580
29581   arg1 = (Dali::Actor *)jarg1;
29582   if (!jarg2) {
29583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29584     return ;
29585   }
29586   std::string arg2_str(jarg2);
29587   arg2 = &arg2_str;
29588   {
29589     try {
29590       (arg1)->SetName((std::string const &)*arg2);
29591     } catch (std::out_of_range& e) {
29592       {
29593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29594       };
29595     } catch (std::exception& e) {
29596       {
29597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29598       };
29599     } catch (...) {
29600       {
29601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29602       };
29603     }
29604   }
29605
29606   //argout typemap for const std::string&
29607
29608 }
29609
29610
29611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29612   unsigned int jresult ;
29613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29614   unsigned int result;
29615
29616   arg1 = (Dali::Actor *)jarg1;
29617   {
29618     try {
29619       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29620     } catch (std::out_of_range& e) {
29621       {
29622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29623       };
29624     } catch (std::exception& e) {
29625       {
29626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29631       };
29632     }
29633   }
29634   jresult = result;
29635   return jresult;
29636 }
29637
29638
29639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29640   unsigned int jresult ;
29641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29642   bool result;
29643
29644   arg1 = (Dali::Actor *)jarg1;
29645   {
29646     try {
29647       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29648     } catch (std::out_of_range& e) {
29649       {
29650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29651       };
29652     } catch (std::exception& e) {
29653       {
29654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29655       };
29656     } catch (...) {
29657       {
29658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29659       };
29660     }
29661   }
29662   jresult = result;
29663   return jresult;
29664 }
29665
29666
29667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29668   unsigned int jresult ;
29669   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29670   bool result;
29671
29672   arg1 = (Dali::Actor *)jarg1;
29673   {
29674     try {
29675       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29676     } catch (std::out_of_range& e) {
29677       {
29678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29679       };
29680     } catch (std::exception& e) {
29681       {
29682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29683       };
29684     } catch (...) {
29685       {
29686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29687       };
29688     }
29689   }
29690   jresult = result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29696   unsigned int jresult ;
29697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29698   bool result;
29699
29700   arg1 = (Dali::Actor *)jarg1;
29701   {
29702     try {
29703       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29704     } catch (std::out_of_range& e) {
29705       {
29706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29707       };
29708     } catch (std::exception& e) {
29709       {
29710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29711       };
29712     } catch (...) {
29713       {
29714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29715       };
29716     }
29717   }
29718   jresult = result;
29719   return jresult;
29720 }
29721
29722
29723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29724   void * jresult ;
29725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29726   Dali::Layer result;
29727
29728   arg1 = (Dali::Actor *)jarg1;
29729   {
29730     try {
29731       result = (arg1)->GetLayer();
29732     } catch (std::out_of_range& e) {
29733       {
29734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29735       };
29736     } catch (std::exception& e) {
29737       {
29738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29739       };
29740     } catch (...) {
29741       {
29742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29743       };
29744     }
29745   }
29746   jresult = new Dali::Layer((const Dali::Layer &)result);
29747   return jresult;
29748 }
29749
29750
29751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29753   Dali::Actor arg2 ;
29754   Dali::Actor *argp2 ;
29755
29756   arg1 = (Dali::Actor *)jarg1;
29757   argp2 = (Dali::Actor *)jarg2;
29758   if (!argp2) {
29759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29760     return ;
29761   }
29762   arg2 = *argp2;
29763   {
29764     try {
29765       (arg1)->Add(arg2);
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (...) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29777       };
29778     }
29779   }
29780 }
29781
29782
29783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29785   Dali::Actor arg2 ;
29786   Dali::Actor *argp2 ;
29787
29788   arg1 = (Dali::Actor *)jarg1;
29789   argp2 = (Dali::Actor *)jarg2;
29790   if (!argp2) {
29791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29792     return ;
29793   }
29794   arg2 = *argp2;
29795   {
29796     try {
29797       (arg1)->Remove(arg2);
29798     } catch (std::out_of_range& e) {
29799       {
29800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29801       };
29802     } catch (std::exception& e) {
29803       {
29804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29805       };
29806     } catch (...) {
29807       {
29808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29809       };
29810     }
29811   }
29812 }
29813
29814
29815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29817
29818   arg1 = (Dali::Actor *)jarg1;
29819   {
29820     try {
29821       (arg1)->Unparent();
29822     } catch (std::out_of_range& e) {
29823       {
29824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29825       };
29826     } catch (std::exception& e) {
29827       {
29828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29829       };
29830     } catch (...) {
29831       {
29832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29833       };
29834     }
29835   }
29836 }
29837
29838
29839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29840   unsigned int jresult ;
29841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29842   unsigned int result;
29843
29844   arg1 = (Dali::Actor *)jarg1;
29845   {
29846     try {
29847       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29848     } catch (std::out_of_range& e) {
29849       {
29850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29851       };
29852     } catch (std::exception& e) {
29853       {
29854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29855       };
29856     } catch (...) {
29857       {
29858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29859       };
29860     }
29861   }
29862   jresult = result;
29863   return jresult;
29864 }
29865
29866
29867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29868   void * jresult ;
29869   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29870   unsigned int arg2 ;
29871   Dali::Actor result;
29872
29873   arg1 = (Dali::Actor *)jarg1;
29874   arg2 = (unsigned int)jarg2;
29875   {
29876     try {
29877       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29878     } catch (std::out_of_range& e) {
29879       {
29880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (std::exception& e) {
29883       {
29884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29885       };
29886     } catch (...) {
29887       {
29888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29889       };
29890     }
29891   }
29892   jresult = new Dali::Actor((const Dali::Actor &)result);
29893   return jresult;
29894 }
29895
29896
29897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29898   void * jresult ;
29899   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29900   std::string *arg2 = 0 ;
29901   Dali::Actor result;
29902
29903   arg1 = (Dali::Actor *)jarg1;
29904   if (!jarg2) {
29905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29906     return 0;
29907   }
29908   std::string arg2_str(jarg2);
29909   arg2 = &arg2_str;
29910   {
29911     try {
29912       result = (arg1)->FindChildByName((std::string const &)*arg2);
29913     } catch (std::out_of_range& e) {
29914       {
29915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (std::exception& e) {
29918       {
29919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (...) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29924       };
29925     }
29926   }
29927   jresult = new Dali::Actor((const Dali::Actor &)result);
29928
29929   //argout typemap for const std::string&
29930
29931   return jresult;
29932 }
29933
29934
29935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29936   void * jresult ;
29937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29938   unsigned int arg2 ;
29939   Dali::Actor result;
29940
29941   arg1 = (Dali::Actor *)jarg1;
29942   arg2 = (unsigned int)jarg2;
29943   {
29944     try {
29945       result = (arg1)->FindChildById(arg2);
29946     } catch (std::out_of_range& e) {
29947       {
29948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29949       };
29950     } catch (std::exception& e) {
29951       {
29952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (...) {
29955       {
29956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29957       };
29958     }
29959   }
29960   jresult = new Dali::Actor((const Dali::Actor &)result);
29961   return jresult;
29962 }
29963
29964
29965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29966   void * jresult ;
29967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29968   Dali::Actor result;
29969
29970   arg1 = (Dali::Actor *)jarg1;
29971   {
29972     try {
29973       result = ((Dali::Actor const *)arg1)->GetParent();
29974     } catch (std::out_of_range& e) {
29975       {
29976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29977       };
29978     } catch (std::exception& e) {
29979       {
29980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (...) {
29983       {
29984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29985       };
29986     }
29987   }
29988   jresult = new Dali::Actor((const Dali::Actor &)result);
29989   return jresult;
29990 }
29991
29992
29993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29995   Dali::Vector3 *arg2 = 0 ;
29996
29997   arg1 = (Dali::Actor *)jarg1;
29998   arg2 = (Dali::Vector3 *)jarg2;
29999   if (!arg2) {
30000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30001     return ;
30002   }
30003   {
30004     try {
30005       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
30006     } catch (std::out_of_range& e) {
30007       {
30008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30009       };
30010     } catch (std::exception& e) {
30011       {
30012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30013       };
30014     } catch (...) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30017       };
30018     }
30019   }
30020 }
30021
30022
30023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
30024   void * jresult ;
30025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30026   Dali::Vector3 result;
30027
30028   arg1 = (Dali::Actor *)jarg1;
30029   {
30030     try {
30031       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
30032     } catch (std::out_of_range& e) {
30033       {
30034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30035       };
30036     } catch (std::exception& e) {
30037       {
30038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30039       };
30040     } catch (...) {
30041       {
30042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30043       };
30044     }
30045   }
30046   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30047   return jresult;
30048 }
30049
30050
30051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
30052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30053   Dali::Vector3 *arg2 = 0 ;
30054
30055   arg1 = (Dali::Actor *)jarg1;
30056   arg2 = (Dali::Vector3 *)jarg2;
30057   if (!arg2) {
30058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30059     return ;
30060   }
30061   {
30062     try {
30063       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
30064     } catch (std::out_of_range& e) {
30065       {
30066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30067       };
30068     } catch (std::exception& e) {
30069       {
30070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30071       };
30072     } catch (...) {
30073       {
30074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30075       };
30076     }
30077   }
30078 }
30079
30080
30081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30082   void * jresult ;
30083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30084   Dali::Vector3 result;
30085
30086   arg1 = (Dali::Actor *)jarg1;
30087   {
30088     try {
30089       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30090     } catch (std::out_of_range& e) {
30091       {
30092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30093       };
30094     } catch (std::exception& e) {
30095       {
30096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30097       };
30098     } catch (...) {
30099       {
30100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30101       };
30102     }
30103   }
30104   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30105   return jresult;
30106 }
30107
30108
30109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30111   float arg2 ;
30112   float arg3 ;
30113
30114   arg1 = (Dali::Actor *)jarg1;
30115   arg2 = (float)jarg2;
30116   arg3 = (float)jarg3;
30117   {
30118     try {
30119       (arg1)->SetSize(arg2,arg3);
30120     } catch (std::out_of_range& e) {
30121       {
30122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30123       };
30124     } catch (std::exception& e) {
30125       {
30126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30127       };
30128     } catch (...) {
30129       {
30130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30131       };
30132     }
30133   }
30134 }
30135
30136
30137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30139   float arg2 ;
30140   float arg3 ;
30141   float arg4 ;
30142
30143   arg1 = (Dali::Actor *)jarg1;
30144   arg2 = (float)jarg2;
30145   arg3 = (float)jarg3;
30146   arg4 = (float)jarg4;
30147   {
30148     try {
30149       (arg1)->SetSize(arg2,arg3,arg4);
30150     } catch (std::out_of_range& e) {
30151       {
30152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30153       };
30154     } catch (std::exception& e) {
30155       {
30156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30157       };
30158     } catch (...) {
30159       {
30160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30161       };
30162     }
30163   }
30164 }
30165
30166
30167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30169   Dali::Vector2 *arg2 = 0 ;
30170
30171   arg1 = (Dali::Actor *)jarg1;
30172   arg2 = (Dali::Vector2 *)jarg2;
30173   if (!arg2) {
30174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30175     return ;
30176   }
30177   {
30178     try {
30179       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30180     } catch (std::out_of_range& e) {
30181       {
30182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30183       };
30184     } catch (std::exception& e) {
30185       {
30186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30187       };
30188     } catch (...) {
30189       {
30190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30191       };
30192     }
30193   }
30194 }
30195
30196
30197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30199   Dali::Vector3 *arg2 = 0 ;
30200
30201   arg1 = (Dali::Actor *)jarg1;
30202   arg2 = (Dali::Vector3 *)jarg2;
30203   if (!arg2) {
30204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30205     return ;
30206   }
30207   {
30208     try {
30209       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30210     } catch (std::out_of_range& e) {
30211       {
30212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30213       };
30214     } catch (std::exception& e) {
30215       {
30216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30221       };
30222     }
30223   }
30224 }
30225
30226
30227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30228   void * jresult ;
30229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30230   Dali::Vector3 result;
30231
30232   arg1 = (Dali::Actor *)jarg1;
30233   {
30234     try {
30235       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30236     } catch (std::out_of_range& e) {
30237       {
30238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30239       };
30240     } catch (std::exception& e) {
30241       {
30242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30243       };
30244     } catch (...) {
30245       {
30246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30247       };
30248     }
30249   }
30250   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30251   return jresult;
30252 }
30253
30254
30255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30256   void * jresult ;
30257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30258   Dali::Vector3 result;
30259
30260   arg1 = (Dali::Actor *)jarg1;
30261   {
30262     try {
30263       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30264     } catch (std::out_of_range& e) {
30265       {
30266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30267       };
30268     } catch (std::exception& e) {
30269       {
30270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30271       };
30272     } catch (...) {
30273       {
30274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30275       };
30276     }
30277   }
30278   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30279   return jresult;
30280 }
30281
30282
30283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30284   void * jresult ;
30285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30286   Dali::Vector3 result;
30287
30288   arg1 = (Dali::Actor *)jarg1;
30289   {
30290     try {
30291       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (...) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30303       };
30304     }
30305   }
30306   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30307   return jresult;
30308 }
30309
30310
30311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30313   float arg2 ;
30314   float arg3 ;
30315
30316   arg1 = (Dali::Actor *)jarg1;
30317   arg2 = (float)jarg2;
30318   arg3 = (float)jarg3;
30319   {
30320     try {
30321       (arg1)->SetPosition(arg2,arg3);
30322     } catch (std::out_of_range& e) {
30323       {
30324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30325       };
30326     } catch (std::exception& e) {
30327       {
30328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (...) {
30331       {
30332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30333       };
30334     }
30335   }
30336 }
30337
30338
30339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30340   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30341   float arg2 ;
30342   float arg3 ;
30343   float arg4 ;
30344
30345   arg1 = (Dali::Actor *)jarg1;
30346   arg2 = (float)jarg2;
30347   arg3 = (float)jarg3;
30348   arg4 = (float)jarg4;
30349   {
30350     try {
30351       (arg1)->SetPosition(arg2,arg3,arg4);
30352     } catch (std::out_of_range& e) {
30353       {
30354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (std::exception& e) {
30357       {
30358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30371   Dali::Vector3 *arg2 = 0 ;
30372
30373   arg1 = (Dali::Actor *)jarg1;
30374   arg2 = (Dali::Vector3 *)jarg2;
30375   if (!arg2) {
30376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30377     return ;
30378   }
30379   {
30380     try {
30381       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30382     } catch (std::out_of_range& e) {
30383       {
30384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30385       };
30386     } catch (std::exception& e) {
30387       {
30388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30389       };
30390     } catch (...) {
30391       {
30392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30393       };
30394     }
30395   }
30396 }
30397
30398
30399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30400   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30401   float arg2 ;
30402
30403   arg1 = (Dali::Actor *)jarg1;
30404   arg2 = (float)jarg2;
30405   {
30406     try {
30407       (arg1)->SetX(arg2);
30408     } catch (std::out_of_range& e) {
30409       {
30410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30411       };
30412     } catch (std::exception& e) {
30413       {
30414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30415       };
30416     } catch (...) {
30417       {
30418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30419       };
30420     }
30421   }
30422 }
30423
30424
30425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30427   float arg2 ;
30428
30429   arg1 = (Dali::Actor *)jarg1;
30430   arg2 = (float)jarg2;
30431   {
30432     try {
30433       (arg1)->SetY(arg2);
30434     } catch (std::out_of_range& e) {
30435       {
30436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30437       };
30438     } catch (std::exception& e) {
30439       {
30440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30441       };
30442     } catch (...) {
30443       {
30444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30445       };
30446     }
30447   }
30448 }
30449
30450
30451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30452   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30453   float arg2 ;
30454
30455   arg1 = (Dali::Actor *)jarg1;
30456   arg2 = (float)jarg2;
30457   {
30458     try {
30459       (arg1)->SetZ(arg2);
30460     } catch (std::out_of_range& e) {
30461       {
30462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30463       };
30464     } catch (std::exception& e) {
30465       {
30466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30467       };
30468     } catch (...) {
30469       {
30470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30471       };
30472     }
30473   }
30474 }
30475
30476
30477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30479   Dali::Vector3 *arg2 = 0 ;
30480
30481   arg1 = (Dali::Actor *)jarg1;
30482   arg2 = (Dali::Vector3 *)jarg2;
30483   if (!arg2) {
30484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30485     return ;
30486   }
30487   {
30488     try {
30489       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (...) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30501       };
30502     }
30503   }
30504 }
30505
30506
30507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30508   void * jresult ;
30509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30510   Dali::Vector3 result;
30511
30512   arg1 = (Dali::Actor *)jarg1;
30513   {
30514     try {
30515       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30516     } catch (std::out_of_range& e) {
30517       {
30518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30519       };
30520     } catch (std::exception& e) {
30521       {
30522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30523       };
30524     } catch (...) {
30525       {
30526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30527       };
30528     }
30529   }
30530   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30531   return jresult;
30532 }
30533
30534
30535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30536   void * jresult ;
30537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30538   Dali::Vector3 result;
30539
30540   arg1 = (Dali::Actor *)jarg1;
30541   {
30542     try {
30543       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30544     } catch (std::out_of_range& e) {
30545       {
30546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30547       };
30548     } catch (std::exception& e) {
30549       {
30550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30551       };
30552     } catch (...) {
30553       {
30554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30555       };
30556     }
30557   }
30558   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30559   return jresult;
30560 }
30561
30562
30563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30565   bool arg2 ;
30566
30567   arg1 = (Dali::Actor *)jarg1;
30568   arg2 = jarg2 ? true : false;
30569   {
30570     try {
30571       (arg1)->SetInheritPosition(arg2);
30572     } catch (std::out_of_range& e) {
30573       {
30574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30575       };
30576     } catch (std::exception& e) {
30577       {
30578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30583       };
30584     }
30585   }
30586 }
30587
30588
30589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30590   int jresult ;
30591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30592   Dali::PositionInheritanceMode result;
30593
30594   arg1 = (Dali::Actor *)jarg1;
30595   {
30596     try {
30597       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30598     } catch (std::out_of_range& e) {
30599       {
30600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30601       };
30602     } catch (std::exception& e) {
30603       {
30604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30605       };
30606     } catch (...) {
30607       {
30608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30609       };
30610     }
30611   }
30612   jresult = (int)result;
30613   return jresult;
30614 }
30615
30616
30617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30618   unsigned int jresult ;
30619   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30620   bool result;
30621
30622   arg1 = (Dali::Actor *)jarg1;
30623   {
30624     try {
30625       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30626     } catch (std::out_of_range& e) {
30627       {
30628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30629       };
30630     } catch (std::exception& e) {
30631       {
30632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30633       };
30634     } catch (...) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30637       };
30638     }
30639   }
30640   jresult = result;
30641   return jresult;
30642 }
30643
30644
30645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30647   Dali::Degree *arg2 = 0 ;
30648   Dali::Vector3 *arg3 = 0 ;
30649
30650   arg1 = (Dali::Actor *)jarg1;
30651   arg2 = (Dali::Degree *)jarg2;
30652   if (!arg2) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30654     return ;
30655   }
30656   arg3 = (Dali::Vector3 *)jarg3;
30657   if (!arg3) {
30658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30659     return ;
30660   }
30661   {
30662     try {
30663       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30664     } catch (std::out_of_range& e) {
30665       {
30666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30667       };
30668     } catch (std::exception& e) {
30669       {
30670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30671       };
30672     } catch (...) {
30673       {
30674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30675       };
30676     }
30677   }
30678 }
30679
30680
30681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30683   Dali::Radian *arg2 = 0 ;
30684   Dali::Vector3 *arg3 = 0 ;
30685
30686   arg1 = (Dali::Actor *)jarg1;
30687   arg2 = (Dali::Radian *)jarg2;
30688   if (!arg2) {
30689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30690     return ;
30691   }
30692   arg3 = (Dali::Vector3 *)jarg3;
30693   if (!arg3) {
30694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30695     return ;
30696   }
30697   {
30698     try {
30699       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30700     } catch (std::out_of_range& e) {
30701       {
30702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30703       };
30704     } catch (std::exception& e) {
30705       {
30706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30707       };
30708     } catch (...) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30711       };
30712     }
30713   }
30714 }
30715
30716
30717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30719   Dali::Quaternion *arg2 = 0 ;
30720
30721   arg1 = (Dali::Actor *)jarg1;
30722   arg2 = (Dali::Quaternion *)jarg2;
30723   if (!arg2) {
30724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30725     return ;
30726   }
30727   {
30728     try {
30729       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30730     } catch (std::out_of_range& e) {
30731       {
30732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30733       };
30734     } catch (std::exception& e) {
30735       {
30736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30737       };
30738     } catch (...) {
30739       {
30740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30741       };
30742     }
30743   }
30744 }
30745
30746
30747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30749   Dali::Degree *arg2 = 0 ;
30750   Dali::Vector3 *arg3 = 0 ;
30751
30752   arg1 = (Dali::Actor *)jarg1;
30753   arg2 = (Dali::Degree *)jarg2;
30754   if (!arg2) {
30755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30756     return ;
30757   }
30758   arg3 = (Dali::Vector3 *)jarg3;
30759   if (!arg3) {
30760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30761     return ;
30762   }
30763   {
30764     try {
30765       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30766     } catch (std::out_of_range& e) {
30767       {
30768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30769       };
30770     } catch (std::exception& e) {
30771       {
30772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30773       };
30774     } catch (...) {
30775       {
30776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30777       };
30778     }
30779   }
30780 }
30781
30782
30783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30785   Dali::Radian *arg2 = 0 ;
30786   Dali::Vector3 *arg3 = 0 ;
30787
30788   arg1 = (Dali::Actor *)jarg1;
30789   arg2 = (Dali::Radian *)jarg2;
30790   if (!arg2) {
30791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30792     return ;
30793   }
30794   arg3 = (Dali::Vector3 *)jarg3;
30795   if (!arg3) {
30796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30797     return ;
30798   }
30799   {
30800     try {
30801       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30802     } catch (std::out_of_range& e) {
30803       {
30804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30805       };
30806     } catch (std::exception& e) {
30807       {
30808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30809       };
30810     } catch (...) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30813       };
30814     }
30815   }
30816 }
30817
30818
30819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30821   Dali::Quaternion *arg2 = 0 ;
30822
30823   arg1 = (Dali::Actor *)jarg1;
30824   arg2 = (Dali::Quaternion *)jarg2;
30825   if (!arg2) {
30826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30827     return ;
30828   }
30829   {
30830     try {
30831       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30832     } catch (std::out_of_range& e) {
30833       {
30834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30835       };
30836     } catch (std::exception& e) {
30837       {
30838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30839       };
30840     } catch (...) {
30841       {
30842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30843       };
30844     }
30845   }
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30850   void * jresult ;
30851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30852   Dali::Quaternion result;
30853
30854   arg1 = (Dali::Actor *)jarg1;
30855   {
30856     try {
30857       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30858     } catch (std::out_of_range& e) {
30859       {
30860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30861       };
30862     } catch (std::exception& e) {
30863       {
30864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30865       };
30866     } catch (...) {
30867       {
30868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30869       };
30870     }
30871   }
30872   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30879   bool arg2 ;
30880
30881   arg1 = (Dali::Actor *)jarg1;
30882   arg2 = jarg2 ? true : false;
30883   {
30884     try {
30885       (arg1)->SetInheritOrientation(arg2);
30886     } catch (std::out_of_range& e) {
30887       {
30888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30889       };
30890     } catch (std::exception& e) {
30891       {
30892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (...) {
30895       {
30896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30897       };
30898     }
30899   }
30900 }
30901
30902
30903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30904   unsigned int jresult ;
30905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30906   bool result;
30907
30908   arg1 = (Dali::Actor *)jarg1;
30909   {
30910     try {
30911       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30912     } catch (std::out_of_range& e) {
30913       {
30914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30915       };
30916     } catch (std::exception& e) {
30917       {
30918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30919       };
30920     } catch (...) {
30921       {
30922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30923       };
30924     }
30925   }
30926   jresult = result;
30927   return jresult;
30928 }
30929
30930
30931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30932   void * jresult ;
30933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30934   Dali::Quaternion result;
30935
30936   arg1 = (Dali::Actor *)jarg1;
30937   {
30938     try {
30939       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30940     } catch (std::out_of_range& e) {
30941       {
30942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30943       };
30944     } catch (std::exception& e) {
30945       {
30946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (...) {
30949       {
30950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30951       };
30952     }
30953   }
30954   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30955   return jresult;
30956 }
30957
30958
30959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30961   float arg2 ;
30962
30963   arg1 = (Dali::Actor *)jarg1;
30964   arg2 = (float)jarg2;
30965   {
30966     try {
30967       (arg1)->SetScale(arg2);
30968     } catch (std::out_of_range& e) {
30969       {
30970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30971       };
30972     } catch (std::exception& e) {
30973       {
30974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30975       };
30976     } catch (...) {
30977       {
30978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30979       };
30980     }
30981   }
30982 }
30983
30984
30985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30987   float arg2 ;
30988   float arg3 ;
30989   float arg4 ;
30990
30991   arg1 = (Dali::Actor *)jarg1;
30992   arg2 = (float)jarg2;
30993   arg3 = (float)jarg3;
30994   arg4 = (float)jarg4;
30995   {
30996     try {
30997       (arg1)->SetScale(arg2,arg3,arg4);
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31005       };
31006     } catch (...) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31009       };
31010     }
31011   }
31012 }
31013
31014
31015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
31016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31017   Dali::Vector3 *arg2 = 0 ;
31018
31019   arg1 = (Dali::Actor *)jarg1;
31020   arg2 = (Dali::Vector3 *)jarg2;
31021   if (!arg2) {
31022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31023     return ;
31024   }
31025   {
31026     try {
31027       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
31028     } catch (std::out_of_range& e) {
31029       {
31030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31031       };
31032     } catch (std::exception& e) {
31033       {
31034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31035       };
31036     } catch (...) {
31037       {
31038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31039       };
31040     }
31041   }
31042 }
31043
31044
31045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
31046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31047   Dali::Vector3 *arg2 = 0 ;
31048
31049   arg1 = (Dali::Actor *)jarg1;
31050   arg2 = (Dali::Vector3 *)jarg2;
31051   if (!arg2) {
31052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31053     return ;
31054   }
31055   {
31056     try {
31057       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
31058     } catch (std::out_of_range& e) {
31059       {
31060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31061       };
31062     } catch (std::exception& e) {
31063       {
31064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31065       };
31066     } catch (...) {
31067       {
31068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31069       };
31070     }
31071   }
31072 }
31073
31074
31075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
31076   void * jresult ;
31077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31078   Dali::Vector3 result;
31079
31080   arg1 = (Dali::Actor *)jarg1;
31081   {
31082     try {
31083       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (...) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31095       };
31096     }
31097   }
31098   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31099   return jresult;
31100 }
31101
31102
31103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31104   void * jresult ;
31105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31106   Dali::Vector3 result;
31107
31108   arg1 = (Dali::Actor *)jarg1;
31109   {
31110     try {
31111       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31133   bool arg2 ;
31134
31135   arg1 = (Dali::Actor *)jarg1;
31136   arg2 = jarg2 ? true : false;
31137   {
31138     try {
31139       (arg1)->SetInheritScale(arg2);
31140     } catch (std::out_of_range& e) {
31141       {
31142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31143       };
31144     } catch (std::exception& e) {
31145       {
31146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31147       };
31148     } catch (...) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31151       };
31152     }
31153   }
31154 }
31155
31156
31157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31158   unsigned int jresult ;
31159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31160   bool result;
31161
31162   arg1 = (Dali::Actor *)jarg1;
31163   {
31164     try {
31165       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31166     } catch (std::out_of_range& e) {
31167       {
31168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31169       };
31170     } catch (std::exception& e) {
31171       {
31172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31173       };
31174     } catch (...) {
31175       {
31176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31177       };
31178     }
31179   }
31180   jresult = result;
31181   return jresult;
31182 }
31183
31184
31185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31186   void * jresult ;
31187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31188   Dali::Matrix result;
31189
31190   arg1 = (Dali::Actor *)jarg1;
31191   {
31192     try {
31193       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31194     } catch (std::out_of_range& e) {
31195       {
31196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31197       };
31198     } catch (std::exception& e) {
31199       {
31200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31201       };
31202     } catch (...) {
31203       {
31204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31205       };
31206     }
31207   }
31208   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31209   return jresult;
31210 }
31211
31212
31213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31215   bool arg2 ;
31216
31217   arg1 = (Dali::Actor *)jarg1;
31218   arg2 = jarg2 ? true : false;
31219   {
31220     try {
31221       (arg1)->SetVisible(arg2);
31222     } catch (std::out_of_range& e) {
31223       {
31224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31225       };
31226     } catch (std::exception& e) {
31227       {
31228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31229       };
31230     } catch (...) {
31231       {
31232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31233       };
31234     }
31235   }
31236 }
31237
31238
31239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31240   unsigned int jresult ;
31241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31242   bool result;
31243
31244   arg1 = (Dali::Actor *)jarg1;
31245   {
31246     try {
31247       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31248     } catch (std::out_of_range& e) {
31249       {
31250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31251       };
31252     } catch (std::exception& e) {
31253       {
31254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31255       };
31256     } catch (...) {
31257       {
31258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31259       };
31260     }
31261   }
31262   jresult = result;
31263   return jresult;
31264 }
31265
31266
31267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31269   float arg2 ;
31270
31271   arg1 = (Dali::Actor *)jarg1;
31272   arg2 = (float)jarg2;
31273   {
31274     try {
31275       (arg1)->SetOpacity(arg2);
31276     } catch (std::out_of_range& e) {
31277       {
31278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31279       };
31280     } catch (std::exception& e) {
31281       {
31282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31283       };
31284     } catch (...) {
31285       {
31286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31287       };
31288     }
31289   }
31290 }
31291
31292
31293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31294   float jresult ;
31295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31296   float result;
31297
31298   arg1 = (Dali::Actor *)jarg1;
31299   {
31300     try {
31301       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31302     } catch (std::out_of_range& e) {
31303       {
31304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31305       };
31306     } catch (std::exception& e) {
31307       {
31308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31309       };
31310     } catch (...) {
31311       {
31312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31313       };
31314     }
31315   }
31316   jresult = result;
31317   return jresult;
31318 }
31319
31320
31321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31323   Dali::Vector4 *arg2 = 0 ;
31324
31325   arg1 = (Dali::Actor *)jarg1;
31326   arg2 = (Dali::Vector4 *)jarg2;
31327   if (!arg2) {
31328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31329     return ;
31330   }
31331   {
31332     try {
31333       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31334     } catch (std::out_of_range& e) {
31335       {
31336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31337       };
31338     } catch (std::exception& e) {
31339       {
31340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31341       };
31342     } catch (...) {
31343       {
31344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31345       };
31346     }
31347   }
31348 }
31349
31350
31351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31352   void * jresult ;
31353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31354   Dali::Vector4 result;
31355
31356   arg1 = (Dali::Actor *)jarg1;
31357   {
31358     try {
31359       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31360     } catch (std::out_of_range& e) {
31361       {
31362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31363       };
31364     } catch (std::exception& e) {
31365       {
31366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31367       };
31368     } catch (...) {
31369       {
31370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31371       };
31372     }
31373   }
31374   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31375   return jresult;
31376 }
31377
31378
31379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31381   Dali::ColorMode arg2 ;
31382
31383   arg1 = (Dali::Actor *)jarg1;
31384   arg2 = (Dali::ColorMode)jarg2;
31385   {
31386     try {
31387       (arg1)->SetColorMode(arg2);
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31395       };
31396     } catch (...) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31399       };
31400     }
31401   }
31402 }
31403
31404
31405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31406   int jresult ;
31407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31408   Dali::ColorMode result;
31409
31410   arg1 = (Dali::Actor *)jarg1;
31411   {
31412     try {
31413       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31414     } catch (std::out_of_range& e) {
31415       {
31416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31417       };
31418     } catch (std::exception& e) {
31419       {
31420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31421       };
31422     } catch (...) {
31423       {
31424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31425       };
31426     }
31427   }
31428   jresult = (int)result;
31429   return jresult;
31430 }
31431
31432
31433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31434   void * jresult ;
31435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31436   Dali::Vector4 result;
31437
31438   arg1 = (Dali::Actor *)jarg1;
31439   {
31440     try {
31441       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31442     } catch (std::out_of_range& e) {
31443       {
31444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31445       };
31446     } catch (std::exception& e) {
31447       {
31448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31449       };
31450     } catch (...) {
31451       {
31452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31453       };
31454     }
31455   }
31456   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31457   return jresult;
31458 }
31459
31460
31461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31463   Dali::DrawMode::Type arg2 ;
31464
31465   arg1 = (Dali::Actor *)jarg1;
31466   arg2 = (Dali::DrawMode::Type)jarg2;
31467   {
31468     try {
31469       (arg1)->SetDrawMode(arg2);
31470     } catch (std::out_of_range& e) {
31471       {
31472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31473       };
31474     } catch (std::exception& e) {
31475       {
31476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31477       };
31478     } catch (...) {
31479       {
31480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31481       };
31482     }
31483   }
31484 }
31485
31486
31487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31488   int jresult ;
31489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31490   Dali::DrawMode::Type result;
31491
31492   arg1 = (Dali::Actor *)jarg1;
31493   {
31494     try {
31495       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31496     } catch (std::out_of_range& e) {
31497       {
31498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31499       };
31500     } catch (std::exception& e) {
31501       {
31502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31503       };
31504     } catch (...) {
31505       {
31506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31507       };
31508     }
31509   }
31510   jresult = (int)result;
31511   return jresult;
31512 }
31513
31514
31515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31517   bool arg2 ;
31518
31519   arg1 = (Dali::Actor *)jarg1;
31520   arg2 = jarg2 ? true : false;
31521   {
31522     try {
31523       (arg1)->SetSensitive(arg2);
31524     } catch (std::out_of_range& e) {
31525       {
31526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31527       };
31528     } catch (std::exception& e) {
31529       {
31530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31531       };
31532     } catch (...) {
31533       {
31534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31535       };
31536     }
31537   }
31538 }
31539
31540
31541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31542   unsigned int jresult ;
31543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31544   bool result;
31545
31546   arg1 = (Dali::Actor *)jarg1;
31547   {
31548     try {
31549       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31550     } catch (std::out_of_range& e) {
31551       {
31552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31553       };
31554     } catch (std::exception& e) {
31555       {
31556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31557       };
31558     } catch (...) {
31559       {
31560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31561       };
31562     }
31563   }
31564   jresult = result;
31565   return jresult;
31566 }
31567
31568
31569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31570   unsigned int jresult ;
31571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31572   float *arg2 = 0 ;
31573   float *arg3 = 0 ;
31574   float arg4 ;
31575   float arg5 ;
31576   bool result;
31577
31578   arg1 = (Dali::Actor *)jarg1;
31579   arg2 = (float *)jarg2;
31580   arg3 = (float *)jarg3;
31581   arg4 = (float)jarg4;
31582   arg5 = (float)jarg5;
31583   {
31584     try {
31585       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31593       };
31594     } catch (...) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31597       };
31598     }
31599   }
31600   jresult = result;
31601   return jresult;
31602 }
31603
31604
31605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31607   bool arg2 ;
31608
31609   arg1 = (Dali::Actor *)jarg1;
31610   arg2 = jarg2 ? true : false;
31611   {
31612     try {
31613       (arg1)->SetLeaveRequired(arg2);
31614     } catch (std::out_of_range& e) {
31615       {
31616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31617       };
31618     } catch (std::exception& e) {
31619       {
31620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31621       };
31622     } catch (...) {
31623       {
31624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31625       };
31626     }
31627   }
31628 }
31629
31630
31631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31632   unsigned int jresult ;
31633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31634   bool result;
31635
31636   arg1 = (Dali::Actor *)jarg1;
31637   {
31638     try {
31639       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31640     } catch (std::out_of_range& e) {
31641       {
31642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31643       };
31644     } catch (std::exception& e) {
31645       {
31646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31647       };
31648     } catch (...) {
31649       {
31650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31651       };
31652     }
31653   }
31654   jresult = result;
31655   return jresult;
31656 }
31657
31658
31659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31661   bool arg2 ;
31662
31663   arg1 = (Dali::Actor *)jarg1;
31664   arg2 = jarg2 ? true : false;
31665   {
31666     try {
31667       (arg1)->SetKeyboardFocusable(arg2);
31668     } catch (std::out_of_range& e) {
31669       {
31670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31671       };
31672     } catch (std::exception& e) {
31673       {
31674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31675       };
31676     } catch (...) {
31677       {
31678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31679       };
31680     }
31681   }
31682 }
31683
31684
31685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31686   unsigned int jresult ;
31687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31688   bool result;
31689
31690   arg1 = (Dali::Actor *)jarg1;
31691   {
31692     try {
31693       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31694     } catch (std::out_of_range& e) {
31695       {
31696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31697       };
31698     } catch (std::exception& e) {
31699       {
31700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31701       };
31702     } catch (...) {
31703       {
31704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31705       };
31706     }
31707   }
31708   jresult = result;
31709   return jresult;
31710 }
31711
31712
31713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31715   Dali::ResizePolicy::Type arg2 ;
31716   Dali::Dimension::Type arg3 ;
31717
31718   arg1 = (Dali::Actor *)jarg1;
31719   arg2 = (Dali::ResizePolicy::Type)jarg2;
31720   arg3 = (Dali::Dimension::Type)jarg3;
31721   {
31722     try {
31723       (arg1)->SetResizePolicy(arg2,arg3);
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31731       };
31732     } catch (...) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31735       };
31736     }
31737   }
31738 }
31739
31740
31741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31742   int jresult ;
31743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31744   Dali::Dimension::Type arg2 ;
31745   Dali::ResizePolicy::Type result;
31746
31747   arg1 = (Dali::Actor *)jarg1;
31748   arg2 = (Dali::Dimension::Type)jarg2;
31749   {
31750     try {
31751       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31752     } catch (std::out_of_range& e) {
31753       {
31754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31755       };
31756     } catch (std::exception& e) {
31757       {
31758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31759       };
31760     } catch (...) {
31761       {
31762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31763       };
31764     }
31765   }
31766   jresult = (int)result;
31767   return jresult;
31768 }
31769
31770
31771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31773   Dali::SizeScalePolicy::Type arg2 ;
31774
31775   arg1 = (Dali::Actor *)jarg1;
31776   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31777   {
31778     try {
31779       (arg1)->SetSizeScalePolicy(arg2);
31780     } catch (std::out_of_range& e) {
31781       {
31782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31783       };
31784     } catch (std::exception& e) {
31785       {
31786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31787       };
31788     } catch (...) {
31789       {
31790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31791       };
31792     }
31793   }
31794 }
31795
31796
31797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31798   int jresult ;
31799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31800   Dali::SizeScalePolicy::Type result;
31801
31802   arg1 = (Dali::Actor *)jarg1;
31803   {
31804     try {
31805       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31806     } catch (std::out_of_range& e) {
31807       {
31808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31809       };
31810     } catch (std::exception& e) {
31811       {
31812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31813       };
31814     } catch (...) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31817       };
31818     }
31819   }
31820   jresult = (int)result;
31821   return jresult;
31822 }
31823
31824
31825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31827   Dali::Vector3 *arg2 = 0 ;
31828
31829   arg1 = (Dali::Actor *)jarg1;
31830   arg2 = (Dali::Vector3 *)jarg2;
31831   if (!arg2) {
31832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31833     return ;
31834   }
31835   {
31836     try {
31837       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31838     } catch (std::out_of_range& e) {
31839       {
31840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31841       };
31842     } catch (std::exception& e) {
31843       {
31844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31845       };
31846     } catch (...) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31849       };
31850     }
31851   }
31852 }
31853
31854
31855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31856   void * jresult ;
31857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31858   Dali::Vector3 result;
31859
31860   arg1 = (Dali::Actor *)jarg1;
31861   {
31862     try {
31863       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31864     } catch (std::out_of_range& e) {
31865       {
31866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (std::exception& e) {
31869       {
31870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (...) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31875       };
31876     }
31877   }
31878   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31879   return jresult;
31880 }
31881
31882
31883 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31884   float jresult ;
31885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31886   float arg2 ;
31887   float result;
31888
31889   arg1 = (Dali::Actor *)jarg1;
31890   arg2 = (float)jarg2;
31891   {
31892     try {
31893       result = (float)(arg1)->GetHeightForWidth(arg2);
31894     } catch (std::out_of_range& e) {
31895       {
31896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31897       };
31898     } catch (std::exception& e) {
31899       {
31900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31901       };
31902     } catch (...) {
31903       {
31904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31905       };
31906     }
31907   }
31908   jresult = result;
31909   return jresult;
31910 }
31911
31912
31913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31914   float jresult ;
31915   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31916   float arg2 ;
31917   float result;
31918
31919   arg1 = (Dali::Actor *)jarg1;
31920   arg2 = (float)jarg2;
31921   {
31922     try {
31923       result = (float)(arg1)->GetWidthForHeight(arg2);
31924     } catch (std::out_of_range& e) {
31925       {
31926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31927       };
31928     } catch (std::exception& e) {
31929       {
31930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31931       };
31932     } catch (...) {
31933       {
31934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31935       };
31936     }
31937   }
31938   jresult = result;
31939   return jresult;
31940 }
31941
31942
31943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31944   float jresult ;
31945   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31946   Dali::Dimension::Type arg2 ;
31947   float result;
31948
31949   arg1 = (Dali::Actor *)jarg1;
31950   arg2 = (Dali::Dimension::Type)jarg2;
31951   {
31952     try {
31953       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31954     } catch (std::out_of_range& e) {
31955       {
31956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31957       };
31958     } catch (std::exception& e) {
31959       {
31960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31961       };
31962     } catch (...) {
31963       {
31964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31965       };
31966     }
31967   }
31968   jresult = result;
31969   return jresult;
31970 }
31971
31972
31973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31975   Dali::Padding *arg2 = 0 ;
31976
31977   arg1 = (Dali::Actor *)jarg1;
31978   arg2 = (Dali::Padding *)jarg2;
31979   if (!arg2) {
31980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31981     return ;
31982   }
31983   {
31984     try {
31985       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31986     } catch (std::out_of_range& e) {
31987       {
31988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31989       };
31990     } catch (std::exception& e) {
31991       {
31992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31993       };
31994     } catch (...) {
31995       {
31996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31997       };
31998     }
31999   }
32000 }
32001
32002
32003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
32004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32005   Dali::Padding *arg2 = 0 ;
32006
32007   arg1 = (Dali::Actor *)jarg1;
32008   arg2 = (Dali::Padding *)jarg2;
32009   if (!arg2) {
32010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
32011     return ;
32012   }
32013   {
32014     try {
32015       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
32016     } catch (std::out_of_range& e) {
32017       {
32018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32019       };
32020     } catch (std::exception& e) {
32021       {
32022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32023       };
32024     } catch (...) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32027       };
32028     }
32029   }
32030 }
32031
32032
32033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
32034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32035   Dali::Vector2 *arg2 = 0 ;
32036
32037   arg1 = (Dali::Actor *)jarg1;
32038   arg2 = (Dali::Vector2 *)jarg2;
32039   if (!arg2) {
32040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32041     return ;
32042   }
32043   {
32044     try {
32045       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
32046     } catch (std::out_of_range& e) {
32047       {
32048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32049       };
32050     } catch (std::exception& e) {
32051       {
32052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32053       };
32054     } catch (...) {
32055       {
32056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32057       };
32058     }
32059   }
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
32064   void * jresult ;
32065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32066   Dali::Vector2 result;
32067
32068   arg1 = (Dali::Actor *)jarg1;
32069   {
32070     try {
32071       result = (arg1)->GetMinimumSize();
32072     } catch (std::out_of_range& e) {
32073       {
32074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (std::exception& e) {
32077       {
32078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32087   return jresult;
32088 }
32089
32090
32091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32092   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32093   Dali::Vector2 *arg2 = 0 ;
32094
32095   arg1 = (Dali::Actor *)jarg1;
32096   arg2 = (Dali::Vector2 *)jarg2;
32097   if (!arg2) {
32098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32099     return ;
32100   }
32101   {
32102     try {
32103       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32104     } catch (std::out_of_range& e) {
32105       {
32106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32107       };
32108     } catch (std::exception& e) {
32109       {
32110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32111       };
32112     } catch (...) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32115       };
32116     }
32117   }
32118 }
32119
32120
32121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32122   void * jresult ;
32123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32124   Dali::Vector2 result;
32125
32126   arg1 = (Dali::Actor *)jarg1;
32127   {
32128     try {
32129       result = (arg1)->GetMaximumSize();
32130     } catch (std::out_of_range& e) {
32131       {
32132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32133       };
32134     } catch (std::exception& e) {
32135       {
32136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32137       };
32138     } catch (...) {
32139       {
32140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32141       };
32142     }
32143   }
32144   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32145   return jresult;
32146 }
32147
32148
32149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32150   int jresult ;
32151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32152   int result;
32153
32154   arg1 = (Dali::Actor *)jarg1;
32155   {
32156     try {
32157       result = (int)(arg1)->GetHierarchyDepth();
32158     } catch (std::out_of_range& e) {
32159       {
32160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32161       };
32162     } catch (std::exception& e) {
32163       {
32164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32165       };
32166     } catch (...) {
32167       {
32168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32169       };
32170     }
32171   }
32172   jresult = result;
32173   return jresult;
32174 }
32175
32176
32177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32178   unsigned int jresult ;
32179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32180   Dali::Renderer *arg2 = 0 ;
32181   unsigned int result;
32182
32183   arg1 = (Dali::Actor *)jarg1;
32184   arg2 = (Dali::Renderer *)jarg2;
32185   if (!arg2) {
32186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32187     return 0;
32188   }
32189   {
32190     try {
32191       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32192     } catch (std::out_of_range& e) {
32193       {
32194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32195       };
32196     } catch (std::exception& e) {
32197       {
32198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32199       };
32200     } catch (...) {
32201       {
32202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32203       };
32204     }
32205   }
32206   jresult = result;
32207   return jresult;
32208 }
32209
32210
32211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32212   unsigned int jresult ;
32213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32214   unsigned int result;
32215
32216   arg1 = (Dali::Actor *)jarg1;
32217   {
32218     try {
32219       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32220     } catch (std::out_of_range& e) {
32221       {
32222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32223       };
32224     } catch (std::exception& e) {
32225       {
32226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32227       };
32228     } catch (...) {
32229       {
32230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32231       };
32232     }
32233   }
32234   jresult = result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32240   void * jresult ;
32241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32242   unsigned int arg2 ;
32243   Dali::Renderer result;
32244
32245   arg1 = (Dali::Actor *)jarg1;
32246   arg2 = (unsigned int)jarg2;
32247   {
32248     try {
32249       result = (arg1)->GetRendererAt(arg2);
32250     } catch (std::out_of_range& e) {
32251       {
32252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (std::exception& e) {
32255       {
32256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32257       };
32258     } catch (...) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32261       };
32262     }
32263   }
32264   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32265   return jresult;
32266 }
32267
32268
32269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32270   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32271   Dali::Renderer *arg2 = 0 ;
32272
32273   arg1 = (Dali::Actor *)jarg1;
32274   arg2 = (Dali::Renderer *)jarg2;
32275   if (!arg2) {
32276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32277     return ;
32278   }
32279   {
32280     try {
32281       (arg1)->RemoveRenderer(*arg2);
32282     } catch (std::out_of_range& e) {
32283       {
32284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32285       };
32286     } catch (std::exception& e) {
32287       {
32288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32289       };
32290     } catch (...) {
32291       {
32292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32293       };
32294     }
32295   }
32296 }
32297
32298
32299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32301   unsigned int arg2 ;
32302
32303   arg1 = (Dali::Actor *)jarg1;
32304   arg2 = (unsigned int)jarg2;
32305   {
32306     try {
32307       (arg1)->RemoveRenderer(arg2);
32308     } catch (std::out_of_range& e) {
32309       {
32310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32311       };
32312     } catch (std::exception& e) {
32313       {
32314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32315       };
32316     } catch (...) {
32317       {
32318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32319       };
32320     }
32321   }
32322 }
32323
32324
32325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32326   void * jresult ;
32327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32328   Dali::Actor::TouchSignalType *result = 0 ;
32329
32330   arg1 = (Dali::Actor *)jarg1;
32331   {
32332     try {
32333       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32334     } catch (std::out_of_range& e) {
32335       {
32336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32337       };
32338     } catch (std::exception& e) {
32339       {
32340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32341       };
32342     } catch (...) {
32343       {
32344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32345       };
32346     }
32347   }
32348   jresult = (void *)result;
32349   return jresult;
32350 }
32351
32352
32353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32354   void * jresult ;
32355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32356   Dali::Actor::TouchDataSignalType *result = 0 ;
32357
32358   arg1 = (Dali::Actor *)jarg1;
32359   {
32360     try {
32361       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32362     } catch (std::out_of_range& e) {
32363       {
32364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32365       };
32366     } catch (std::exception& e) {
32367       {
32368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32369       };
32370     } catch (...) {
32371       {
32372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32373       };
32374     }
32375   }
32376   jresult = (void *)result;
32377   return jresult;
32378 }
32379
32380
32381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32382   void * jresult ;
32383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32384   Dali::Actor::HoverSignalType *result = 0 ;
32385
32386   arg1 = (Dali::Actor *)jarg1;
32387   {
32388     try {
32389       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32390     } catch (std::out_of_range& e) {
32391       {
32392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32393       };
32394     } catch (std::exception& e) {
32395       {
32396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32397       };
32398     } catch (...) {
32399       {
32400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32401       };
32402     }
32403   }
32404   jresult = (void *)result;
32405   return jresult;
32406 }
32407
32408
32409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32410   void * jresult ;
32411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32412   Dali::Actor::WheelEventSignalType *result = 0 ;
32413
32414   arg1 = (Dali::Actor *)jarg1;
32415   {
32416     try {
32417       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32418     } catch (std::out_of_range& e) {
32419       {
32420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32421       };
32422     } catch (std::exception& e) {
32423       {
32424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32425       };
32426     } catch (...) {
32427       {
32428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32429       };
32430     }
32431   }
32432   jresult = (void *)result;
32433   return jresult;
32434 }
32435
32436
32437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32438   void * jresult ;
32439   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32440   Dali::Actor::OnStageSignalType *result = 0 ;
32441
32442   arg1 = (Dali::Actor *)jarg1;
32443   {
32444     try {
32445       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32446     } catch (std::out_of_range& e) {
32447       {
32448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32449       };
32450     } catch (std::exception& e) {
32451       {
32452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32453       };
32454     } catch (...) {
32455       {
32456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32457       };
32458     }
32459   }
32460   jresult = (void *)result;
32461   return jresult;
32462 }
32463
32464
32465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32466   void * jresult ;
32467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32468   Dali::Actor::OffStageSignalType *result = 0 ;
32469
32470   arg1 = (Dali::Actor *)jarg1;
32471   {
32472     try {
32473       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32474     } catch (std::out_of_range& e) {
32475       {
32476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32477       };
32478     } catch (std::exception& e) {
32479       {
32480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32481       };
32482     } catch (...) {
32483       {
32484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32485       };
32486     }
32487   }
32488   jresult = (void *)result;
32489   return jresult;
32490 }
32491
32492
32493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32494   void * jresult ;
32495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32496   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32497
32498   arg1 = (Dali::Actor *)jarg1;
32499   {
32500     try {
32501       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32502     } catch (std::out_of_range& e) {
32503       {
32504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32505       };
32506     } catch (std::exception& e) {
32507       {
32508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32509       };
32510     } catch (...) {
32511       {
32512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32513       };
32514     }
32515   }
32516   jresult = (void *)result;
32517   return jresult;
32518 }
32519
32520
32521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32522   Dali::Actor *arg1 = 0 ;
32523
32524   arg1 = (Dali::Actor *)jarg1;
32525   if (!arg1) {
32526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32527     return ;
32528   }
32529   {
32530     try {
32531       Dali::UnparentAndReset(*arg1);
32532     } catch (std::out_of_range& e) {
32533       {
32534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32535       };
32536     } catch (std::exception& e) {
32537       {
32538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32539       };
32540     } catch (...) {
32541       {
32542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32543       };
32544     }
32545   }
32546 }
32547
32548
32549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32550   int jresult ;
32551   int result;
32552
32553   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32554   jresult = (int)result;
32555   return jresult;
32556 }
32557
32558
32559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32560   int jresult ;
32561   int result;
32562
32563   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32564   jresult = (int)result;
32565   return jresult;
32566 }
32567
32568
32569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32570   int jresult ;
32571   int result;
32572
32573   result = (int)Dali::Layer::Property::BEHAVIOR;
32574   jresult = (int)result;
32575   return jresult;
32576 }
32577
32578
32579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32580   void * jresult ;
32581   Dali::Layer::Property *result = 0 ;
32582
32583   {
32584     try {
32585       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32586     } catch (std::out_of_range& e) {
32587       {
32588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32589       };
32590     } catch (std::exception& e) {
32591       {
32592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32593       };
32594     } catch (...) {
32595       {
32596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32597       };
32598     }
32599   }
32600   jresult = (void *)result;
32601   return jresult;
32602 }
32603
32604
32605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32606   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32607
32608   arg1 = (Dali::Layer::Property *)jarg1;
32609   {
32610     try {
32611       delete arg1;
32612     } catch (std::out_of_range& e) {
32613       {
32614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32615       };
32616     } catch (std::exception& e) {
32617       {
32618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32619       };
32620     } catch (...) {
32621       {
32622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32623       };
32624     }
32625   }
32626 }
32627
32628
32629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32630   void * jresult ;
32631   Dali::Layer *result = 0 ;
32632
32633   {
32634     try {
32635       result = (Dali::Layer *)new Dali::Layer();
32636     } catch (std::out_of_range& e) {
32637       {
32638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32639       };
32640     } catch (std::exception& e) {
32641       {
32642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32643       };
32644     } catch (...) {
32645       {
32646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32647       };
32648     }
32649   }
32650   jresult = (void *)result;
32651   return jresult;
32652 }
32653
32654
32655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32656   void * jresult ;
32657   Dali::Layer result;
32658
32659   {
32660     try {
32661       result = Dali::Layer::New();
32662     } catch (std::out_of_range& e) {
32663       {
32664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32665       };
32666     } catch (std::exception& e) {
32667       {
32668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32669       };
32670     } catch (...) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32673       };
32674     }
32675   }
32676   jresult = new Dali::Layer((const Dali::Layer &)result);
32677   return jresult;
32678 }
32679
32680
32681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32682   void * jresult ;
32683   Dali::BaseHandle arg1 ;
32684   Dali::BaseHandle *argp1 ;
32685   Dali::Layer result;
32686
32687   argp1 = (Dali::BaseHandle *)jarg1;
32688   if (!argp1) {
32689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32690     return 0;
32691   }
32692   arg1 = *argp1;
32693   {
32694     try {
32695       result = Dali::Layer::DownCast(arg1);
32696     } catch (std::out_of_range& e) {
32697       {
32698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32699       };
32700     } catch (std::exception& e) {
32701       {
32702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32703       };
32704     } catch (...) {
32705       {
32706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32707       };
32708     }
32709   }
32710   jresult = new Dali::Layer((const Dali::Layer &)result);
32711   return jresult;
32712 }
32713
32714
32715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32716   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32717
32718   arg1 = (Dali::Layer *)jarg1;
32719   {
32720     try {
32721       delete arg1;
32722     } catch (std::out_of_range& e) {
32723       {
32724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32725       };
32726     } catch (std::exception& e) {
32727       {
32728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32729       };
32730     } catch (...) {
32731       {
32732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32733       };
32734     }
32735   }
32736 }
32737
32738
32739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32740   void * jresult ;
32741   Dali::Layer *arg1 = 0 ;
32742   Dali::Layer *result = 0 ;
32743
32744   arg1 = (Dali::Layer *)jarg1;
32745   if (!arg1) {
32746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32747     return 0;
32748   }
32749   {
32750     try {
32751       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32759       };
32760     } catch (...) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32763       };
32764     }
32765   }
32766   jresult = (void *)result;
32767   return jresult;
32768 }
32769
32770
32771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32772   void * jresult ;
32773   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32774   Dali::Layer *arg2 = 0 ;
32775   Dali::Layer *result = 0 ;
32776
32777   arg1 = (Dali::Layer *)jarg1;
32778   arg2 = (Dali::Layer *)jarg2;
32779   if (!arg2) {
32780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32781     return 0;
32782   }
32783   {
32784     try {
32785       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32786     } catch (std::out_of_range& e) {
32787       {
32788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32789       };
32790     } catch (std::exception& e) {
32791       {
32792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32793       };
32794     } catch (...) {
32795       {
32796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32797       };
32798     }
32799   }
32800   jresult = (void *)result;
32801   return jresult;
32802 }
32803
32804
32805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32806   unsigned int jresult ;
32807   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32808   unsigned int result;
32809
32810   arg1 = (Dali::Layer *)jarg1;
32811   {
32812     try {
32813       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32814     } catch (std::out_of_range& e) {
32815       {
32816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32817       };
32818     } catch (std::exception& e) {
32819       {
32820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32821       };
32822     } catch (...) {
32823       {
32824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32825       };
32826     }
32827   }
32828   jresult = result;
32829   return jresult;
32830 }
32831
32832
32833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32834   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32835
32836   arg1 = (Dali::Layer *)jarg1;
32837   {
32838     try {
32839       (arg1)->Raise();
32840     } catch (std::out_of_range& e) {
32841       {
32842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32843       };
32844     } catch (std::exception& e) {
32845       {
32846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32847       };
32848     } catch (...) {
32849       {
32850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32851       };
32852     }
32853   }
32854 }
32855
32856
32857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32858   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32859
32860   arg1 = (Dali::Layer *)jarg1;
32861   {
32862     try {
32863       (arg1)->Lower();
32864     } catch (std::out_of_range& e) {
32865       {
32866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32867       };
32868     } catch (std::exception& e) {
32869       {
32870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32871       };
32872     } catch (...) {
32873       {
32874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32875       };
32876     }
32877   }
32878 }
32879
32880
32881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32882   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32883   Dali::Layer arg2 ;
32884   Dali::Layer *argp2 ;
32885
32886   arg1 = (Dali::Layer *)jarg1;
32887   argp2 = (Dali::Layer *)jarg2;
32888   if (!argp2) {
32889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32890     return ;
32891   }
32892   arg2 = *argp2;
32893   {
32894     try {
32895       (arg1)->RaiseAbove(arg2);
32896     } catch (std::out_of_range& e) {
32897       {
32898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32899       };
32900     } catch (std::exception& e) {
32901       {
32902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32903       };
32904     } catch (...) {
32905       {
32906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32907       };
32908     }
32909   }
32910 }
32911
32912
32913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32914   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32915   Dali::Layer arg2 ;
32916   Dali::Layer *argp2 ;
32917
32918   arg1 = (Dali::Layer *)jarg1;
32919   argp2 = (Dali::Layer *)jarg2;
32920   if (!argp2) {
32921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32922     return ;
32923   }
32924   arg2 = *argp2;
32925   {
32926     try {
32927       (arg1)->LowerBelow(arg2);
32928     } catch (std::out_of_range& e) {
32929       {
32930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32931       };
32932     } catch (std::exception& e) {
32933       {
32934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32935       };
32936     } catch (...) {
32937       {
32938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32939       };
32940     }
32941   }
32942 }
32943
32944
32945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32946   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32947
32948   arg1 = (Dali::Layer *)jarg1;
32949   {
32950     try {
32951       (arg1)->RaiseToTop();
32952     } catch (std::out_of_range& e) {
32953       {
32954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32955       };
32956     } catch (std::exception& e) {
32957       {
32958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32959       };
32960     } catch (...) {
32961       {
32962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32963       };
32964     }
32965   }
32966 }
32967
32968
32969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32970   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32971
32972   arg1 = (Dali::Layer *)jarg1;
32973   {
32974     try {
32975       (arg1)->LowerToBottom();
32976     } catch (std::out_of_range& e) {
32977       {
32978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32979       };
32980     } catch (std::exception& e) {
32981       {
32982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32983       };
32984     } catch (...) {
32985       {
32986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32987       };
32988     }
32989   }
32990 }
32991
32992
32993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32994   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32995   Dali::Layer arg2 ;
32996   Dali::Layer *argp2 ;
32997
32998   arg1 = (Dali::Layer *)jarg1;
32999   argp2 = (Dali::Layer *)jarg2;
33000   if (!argp2) {
33001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33002     return ;
33003   }
33004   arg2 = *argp2;
33005   {
33006     try {
33007       (arg1)->MoveAbove(arg2);
33008     } catch (std::out_of_range& e) {
33009       {
33010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33011       };
33012     } catch (std::exception& e) {
33013       {
33014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33015       };
33016     } catch (...) {
33017       {
33018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33019       };
33020     }
33021   }
33022 }
33023
33024
33025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33026   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33027   Dali::Layer arg2 ;
33028   Dali::Layer *argp2 ;
33029
33030   arg1 = (Dali::Layer *)jarg1;
33031   argp2 = (Dali::Layer *)jarg2;
33032   if (!argp2) {
33033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33034     return ;
33035   }
33036   arg2 = *argp2;
33037   {
33038     try {
33039       (arg1)->MoveBelow(arg2);
33040     } catch (std::out_of_range& e) {
33041       {
33042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33043       };
33044     } catch (std::exception& e) {
33045       {
33046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33047       };
33048     } catch (...) {
33049       {
33050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33051       };
33052     }
33053   }
33054 }
33055
33056
33057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33058   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33059   Dali::Layer::Behavior arg2 ;
33060
33061   arg1 = (Dali::Layer *)jarg1;
33062   arg2 = (Dali::Layer::Behavior)jarg2;
33063   {
33064     try {
33065       (arg1)->SetBehavior(arg2);
33066     } catch (std::out_of_range& e) {
33067       {
33068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33069       };
33070     } catch (std::exception& e) {
33071       {
33072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33073       };
33074     } catch (...) {
33075       {
33076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33077       };
33078     }
33079   }
33080 }
33081
33082
33083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33084   int jresult ;
33085   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33086   Dali::Layer::Behavior result;
33087
33088   arg1 = (Dali::Layer *)jarg1;
33089   {
33090     try {
33091       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33092     } catch (std::out_of_range& e) {
33093       {
33094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33095       };
33096     } catch (std::exception& e) {
33097       {
33098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33099       };
33100     } catch (...) {
33101       {
33102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33103       };
33104     }
33105   }
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33112   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33113   bool arg2 ;
33114
33115   arg1 = (Dali::Layer *)jarg1;
33116   arg2 = jarg2 ? true : false;
33117   {
33118     try {
33119       (arg1)->SetClipping(arg2);
33120     } catch (std::out_of_range& e) {
33121       {
33122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33123       };
33124     } catch (std::exception& e) {
33125       {
33126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33127       };
33128     } catch (...) {
33129       {
33130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33131       };
33132     }
33133   }
33134 }
33135
33136
33137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33138   unsigned int jresult ;
33139   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33140   bool result;
33141
33142   arg1 = (Dali::Layer *)jarg1;
33143   {
33144     try {
33145       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33146     } catch (std::out_of_range& e) {
33147       {
33148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33149       };
33150     } catch (std::exception& e) {
33151       {
33152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33153       };
33154     } catch (...) {
33155       {
33156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33157       };
33158     }
33159   }
33160   jresult = result;
33161   return jresult;
33162 }
33163
33164
33165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33166   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33167   int arg2 ;
33168   int arg3 ;
33169   int arg4 ;
33170   int arg5 ;
33171
33172   arg1 = (Dali::Layer *)jarg1;
33173   arg2 = (int)jarg2;
33174   arg3 = (int)jarg3;
33175   arg4 = (int)jarg4;
33176   arg5 = (int)jarg5;
33177   {
33178     try {
33179       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33180     } catch (std::out_of_range& e) {
33181       {
33182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33183       };
33184     } catch (std::exception& e) {
33185       {
33186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33187       };
33188     } catch (...) {
33189       {
33190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33191       };
33192     }
33193   }
33194 }
33195
33196
33197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33198   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33199   Dali::ClippingBox arg2 ;
33200   Dali::ClippingBox *argp2 ;
33201
33202   arg1 = (Dali::Layer *)jarg1;
33203   argp2 = (Dali::ClippingBox *)jarg2;
33204   if (!argp2) {
33205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33206     return ;
33207   }
33208   arg2 = *argp2;
33209   {
33210     try {
33211       (arg1)->SetClippingBox(arg2);
33212     } catch (std::out_of_range& e) {
33213       {
33214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33215       };
33216     } catch (std::exception& e) {
33217       {
33218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33219       };
33220     } catch (...) {
33221       {
33222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33223       };
33224     }
33225   }
33226 }
33227
33228
33229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33230   void * jresult ;
33231   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33232   Dali::ClippingBox result;
33233
33234   arg1 = (Dali::Layer *)jarg1;
33235   {
33236     try {
33237       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33238     } catch (std::out_of_range& e) {
33239       {
33240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33241       };
33242     } catch (std::exception& e) {
33243       {
33244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33245       };
33246     } catch (...) {
33247       {
33248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33249       };
33250     }
33251   }
33252   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33253   return jresult;
33254 }
33255
33256
33257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33258   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33259   bool arg2 ;
33260
33261   arg1 = (Dali::Layer *)jarg1;
33262   arg2 = jarg2 ? true : false;
33263   {
33264     try {
33265       (arg1)->SetDepthTestDisabled(arg2);
33266     } catch (std::out_of_range& e) {
33267       {
33268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33269       };
33270     } catch (std::exception& e) {
33271       {
33272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33273       };
33274     } catch (...) {
33275       {
33276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33277       };
33278     }
33279   }
33280 }
33281
33282
33283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33284   unsigned int jresult ;
33285   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33286   bool result;
33287
33288   arg1 = (Dali::Layer *)jarg1;
33289   {
33290     try {
33291       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33292     } catch (std::out_of_range& e) {
33293       {
33294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33295       };
33296     } catch (std::exception& e) {
33297       {
33298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33299       };
33300     } catch (...) {
33301       {
33302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33303       };
33304     }
33305   }
33306   jresult = result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33312   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33313   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33314
33315   arg1 = (Dali::Layer *)jarg1;
33316   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33317   {
33318     try {
33319       (arg1)->SetSortFunction(arg2);
33320     } catch (std::out_of_range& e) {
33321       {
33322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33323       };
33324     } catch (std::exception& e) {
33325       {
33326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33327       };
33328     } catch (...) {
33329       {
33330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33331       };
33332     }
33333   }
33334 }
33335
33336
33337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33338   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33339   bool arg2 ;
33340
33341   arg1 = (Dali::Layer *)jarg1;
33342   arg2 = jarg2 ? true : false;
33343   {
33344     try {
33345       (arg1)->SetTouchConsumed(arg2);
33346     } catch (std::out_of_range& e) {
33347       {
33348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33349       };
33350     } catch (std::exception& e) {
33351       {
33352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33353       };
33354     } catch (...) {
33355       {
33356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33357       };
33358     }
33359   }
33360 }
33361
33362
33363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33364   unsigned int jresult ;
33365   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33366   bool result;
33367
33368   arg1 = (Dali::Layer *)jarg1;
33369   {
33370     try {
33371       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33372     } catch (std::out_of_range& e) {
33373       {
33374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33375       };
33376     } catch (std::exception& e) {
33377       {
33378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33379       };
33380     } catch (...) {
33381       {
33382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33383       };
33384     }
33385   }
33386   jresult = result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33392   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33393   bool arg2 ;
33394
33395   arg1 = (Dali::Layer *)jarg1;
33396   arg2 = jarg2 ? true : false;
33397   {
33398     try {
33399       (arg1)->SetHoverConsumed(arg2);
33400     } catch (std::out_of_range& e) {
33401       {
33402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33403       };
33404     } catch (std::exception& e) {
33405       {
33406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33407       };
33408     } catch (...) {
33409       {
33410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33411       };
33412     }
33413   }
33414 }
33415
33416
33417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33418   unsigned int jresult ;
33419   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33420   bool result;
33421
33422   arg1 = (Dali::Layer *)jarg1;
33423   {
33424     try {
33425       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33426     } catch (std::out_of_range& e) {
33427       {
33428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33429       };
33430     } catch (std::exception& e) {
33431       {
33432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33433       };
33434     } catch (...) {
33435       {
33436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33437       };
33438     }
33439   }
33440   jresult = result;
33441   return jresult;
33442 }
33443
33444
33445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33446   void * jresult ;
33447   Dali::Vector4 *result = 0 ;
33448
33449   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33450   jresult = (void *)result;
33451   return jresult;
33452 }
33453
33454
33455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33456   void * jresult ;
33457   Dali::Vector4 *result = 0 ;
33458
33459   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33460   jresult = (void *)result;
33461   return jresult;
33462 }
33463
33464
33465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33466   void * jresult ;
33467   Dali::Stage *result = 0 ;
33468
33469   {
33470     try {
33471       result = (Dali::Stage *)new Dali::Stage();
33472     } catch (std::out_of_range& e) {
33473       {
33474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (std::exception& e) {
33477       {
33478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486   jresult = (void *)result;
33487   return jresult;
33488 }
33489
33490
33491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33492   void * jresult ;
33493   Dali::Stage result;
33494
33495   {
33496     try {
33497       result = Dali::Stage::GetCurrent();
33498     } catch (std::out_of_range& e) {
33499       {
33500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33501       };
33502     } catch (std::exception& e) {
33503       {
33504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33505       };
33506     } catch (...) {
33507       {
33508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33509       };
33510     }
33511   }
33512   jresult = new Dali::Stage((const Dali::Stage &)result);
33513   return jresult;
33514 }
33515
33516
33517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33518   unsigned int jresult ;
33519   bool result;
33520
33521   {
33522     try {
33523       result = (bool)Dali::Stage::IsInstalled();
33524     } catch (std::out_of_range& e) {
33525       {
33526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33527       };
33528     } catch (std::exception& e) {
33529       {
33530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33531       };
33532     } catch (...) {
33533       {
33534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33535       };
33536     }
33537   }
33538   jresult = result;
33539   return jresult;
33540 }
33541
33542
33543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33544   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33545
33546   arg1 = (Dali::Stage *)jarg1;
33547   {
33548     try {
33549       delete arg1;
33550     } catch (std::out_of_range& e) {
33551       {
33552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33553       };
33554     } catch (std::exception& e) {
33555       {
33556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33557       };
33558     } catch (...) {
33559       {
33560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33561       };
33562     }
33563   }
33564 }
33565
33566
33567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33568   void * jresult ;
33569   Dali::Stage *arg1 = 0 ;
33570   Dali::Stage *result = 0 ;
33571
33572   arg1 = (Dali::Stage *)jarg1;
33573   if (!arg1) {
33574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33575     return 0;
33576   }
33577   {
33578     try {
33579       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33580     } catch (std::out_of_range& e) {
33581       {
33582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33583       };
33584     } catch (std::exception& e) {
33585       {
33586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33587       };
33588     } catch (...) {
33589       {
33590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33591       };
33592     }
33593   }
33594   jresult = (void *)result;
33595   return jresult;
33596 }
33597
33598
33599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33600   void * jresult ;
33601   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33602   Dali::Stage *arg2 = 0 ;
33603   Dali::Stage *result = 0 ;
33604
33605   arg1 = (Dali::Stage *)jarg1;
33606   arg2 = (Dali::Stage *)jarg2;
33607   if (!arg2) {
33608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33609     return 0;
33610   }
33611   {
33612     try {
33613       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33614     } catch (std::out_of_range& e) {
33615       {
33616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33617       };
33618     } catch (std::exception& e) {
33619       {
33620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33625       };
33626     }
33627   }
33628   jresult = (void *)result;
33629   return jresult;
33630 }
33631
33632
33633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33634   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33635   Dali::Actor *arg2 = 0 ;
33636
33637   arg1 = (Dali::Stage *)jarg1;
33638   arg2 = (Dali::Actor *)jarg2;
33639   if (!arg2) {
33640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33641     return ;
33642   }
33643   {
33644     try {
33645       (arg1)->Add(*arg2);
33646     } catch (std::out_of_range& e) {
33647       {
33648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33649       };
33650     } catch (std::exception& e) {
33651       {
33652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33653       };
33654     } catch (...) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33657       };
33658     }
33659   }
33660 }
33661
33662
33663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33664   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33665   Dali::Actor *arg2 = 0 ;
33666
33667   arg1 = (Dali::Stage *)jarg1;
33668   arg2 = (Dali::Actor *)jarg2;
33669   if (!arg2) {
33670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33671     return ;
33672   }
33673   {
33674     try {
33675       (arg1)->Remove(*arg2);
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33683       };
33684     } catch (...) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33687       };
33688     }
33689   }
33690 }
33691
33692
33693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33694   void * jresult ;
33695   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33696   Dali::Vector2 result;
33697
33698   arg1 = (Dali::Stage *)jarg1;
33699   {
33700     try {
33701       result = ((Dali::Stage const *)arg1)->GetSize();
33702     } catch (std::out_of_range& e) {
33703       {
33704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33705       };
33706     } catch (std::exception& e) {
33707       {
33708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (...) {
33711       {
33712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33713       };
33714     }
33715   }
33716   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33717   return jresult;
33718 }
33719
33720
33721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33722   void * jresult ;
33723   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33724   Dali::RenderTaskList result;
33725
33726   arg1 = (Dali::Stage *)jarg1;
33727   {
33728     try {
33729       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33730     } catch (std::out_of_range& e) {
33731       {
33732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33733       };
33734     } catch (std::exception& e) {
33735       {
33736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33737       };
33738     } catch (...) {
33739       {
33740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33741       };
33742     }
33743   }
33744   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33745   return jresult;
33746 }
33747
33748
33749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33750   unsigned int jresult ;
33751   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33752   unsigned int result;
33753
33754   arg1 = (Dali::Stage *)jarg1;
33755   {
33756     try {
33757       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33758     } catch (std::out_of_range& e) {
33759       {
33760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33761       };
33762     } catch (std::exception& e) {
33763       {
33764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33765       };
33766     } catch (...) {
33767       {
33768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33769       };
33770     }
33771   }
33772   jresult = result;
33773   return jresult;
33774 }
33775
33776
33777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33778   void * jresult ;
33779   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33780   unsigned int arg2 ;
33781   Dali::Layer result;
33782
33783   arg1 = (Dali::Stage *)jarg1;
33784   arg2 = (unsigned int)jarg2;
33785   {
33786     try {
33787       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33788     } catch (std::out_of_range& e) {
33789       {
33790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33791       };
33792     } catch (std::exception& e) {
33793       {
33794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33799       };
33800     }
33801   }
33802   jresult = new Dali::Layer((const Dali::Layer &)result);
33803   return jresult;
33804 }
33805
33806
33807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33808   void * jresult ;
33809   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33810   Dali::Layer result;
33811
33812   arg1 = (Dali::Stage *)jarg1;
33813   {
33814     try {
33815       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33816     } catch (std::out_of_range& e) {
33817       {
33818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33819       };
33820     } catch (std::exception& e) {
33821       {
33822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33823       };
33824     } catch (...) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33827       };
33828     }
33829   }
33830   jresult = new Dali::Layer((const Dali::Layer &)result);
33831   return jresult;
33832 }
33833
33834
33835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33836   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33837   Dali::Vector4 arg2 ;
33838   Dali::Vector4 *argp2 ;
33839
33840   arg1 = (Dali::Stage *)jarg1;
33841   argp2 = (Dali::Vector4 *)jarg2;
33842   if (!argp2) {
33843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33844     return ;
33845   }
33846   arg2 = *argp2;
33847   {
33848     try {
33849       (arg1)->SetBackgroundColor(arg2);
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33857       };
33858     } catch (...) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33861       };
33862     }
33863   }
33864 }
33865
33866
33867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33868   void * jresult ;
33869   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33870   Dali::Vector4 result;
33871
33872   arg1 = (Dali::Stage *)jarg1;
33873   {
33874     try {
33875       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33876     } catch (std::out_of_range& e) {
33877       {
33878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33879       };
33880     } catch (std::exception& e) {
33881       {
33882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33883       };
33884     } catch (...) {
33885       {
33886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33887       };
33888     }
33889   }
33890   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33891   return jresult;
33892 }
33893
33894
33895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33896   void * jresult ;
33897   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33898   Dali::Vector2 result;
33899
33900   arg1 = (Dali::Stage *)jarg1;
33901   {
33902     try {
33903       result = ((Dali::Stage const *)arg1)->GetDpi();
33904     } catch (std::out_of_range& e) {
33905       {
33906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33907       };
33908     } catch (std::exception& e) {
33909       {
33910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33911       };
33912     } catch (...) {
33913       {
33914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33915       };
33916     }
33917   }
33918   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33919   return jresult;
33920 }
33921
33922
33923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33924   void * jresult ;
33925   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33926   Dali::ObjectRegistry result;
33927
33928   arg1 = (Dali::Stage *)jarg1;
33929   {
33930     try {
33931       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33932     } catch (std::out_of_range& e) {
33933       {
33934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33935       };
33936     } catch (std::exception& e) {
33937       {
33938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33939       };
33940     } catch (...) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33943       };
33944     }
33945   }
33946   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33947   return jresult;
33948 }
33949
33950
33951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33952   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33953   float arg2 ;
33954
33955   arg1 = (Dali::Stage *)jarg1;
33956   arg2 = (float)jarg2;
33957   {
33958     try {
33959       (arg1)->KeepRendering(arg2);
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (...) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33971       };
33972     }
33973   }
33974 }
33975
33976
33977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33978   void * jresult ;
33979   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33980   Dali::Stage::KeyEventSignalType *result = 0 ;
33981
33982   arg1 = (Dali::Stage *)jarg1;
33983   {
33984     try {
33985       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (...) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33997       };
33998     }
33999   }
34000   jresult = (void *)result;
34001   return jresult;
34002 }
34003
34004
34005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
34006   void * jresult ;
34007   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34008   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
34009
34010   arg1 = (Dali::Stage *)jarg1;
34011   {
34012     try {
34013       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
34014     } catch (std::out_of_range& e) {
34015       {
34016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34017       };
34018     } catch (std::exception& e) {
34019       {
34020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34021       };
34022     } catch (...) {
34023       {
34024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34025       };
34026     }
34027   }
34028   jresult = (void *)result;
34029   return jresult;
34030 }
34031
34032
34033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34034   void * jresult ;
34035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34036   Dali::Stage::TouchSignalType *result = 0 ;
34037
34038   arg1 = (Dali::Stage *)jarg1;
34039   {
34040     try {
34041       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34042     } catch (std::out_of_range& e) {
34043       {
34044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34045       };
34046     } catch (std::exception& e) {
34047       {
34048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34049       };
34050     } catch (...) {
34051       {
34052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34053       };
34054     }
34055   }
34056   jresult = (void *)result;
34057   return jresult;
34058 }
34059
34060
34061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34062   void * jresult ;
34063   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34064   Dali::Stage::WheelEventSignalType *result = 0 ;
34065
34066   arg1 = (Dali::Stage *)jarg1;
34067   {
34068     try {
34069       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34070     } catch (std::out_of_range& e) {
34071       {
34072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34073       };
34074     } catch (std::exception& e) {
34075       {
34076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34077       };
34078     } catch (...) {
34079       {
34080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34081       };
34082     }
34083   }
34084   jresult = (void *)result;
34085   return jresult;
34086 }
34087
34088
34089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34090   void * jresult ;
34091   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34092   Dali::Stage::ContextStatusSignal *result = 0 ;
34093
34094   arg1 = (Dali::Stage *)jarg1;
34095   {
34096     try {
34097       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34098     } catch (std::out_of_range& e) {
34099       {
34100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34101       };
34102     } catch (std::exception& e) {
34103       {
34104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34109       };
34110     }
34111   }
34112   jresult = (void *)result;
34113   return jresult;
34114 }
34115
34116
34117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34118   void * jresult ;
34119   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34120   Dali::Stage::ContextStatusSignal *result = 0 ;
34121
34122   arg1 = (Dali::Stage *)jarg1;
34123   {
34124     try {
34125       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34126     } catch (std::out_of_range& e) {
34127       {
34128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34129       };
34130     } catch (std::exception& e) {
34131       {
34132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34133       };
34134     } catch (...) {
34135       {
34136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34137       };
34138     }
34139   }
34140   jresult = (void *)result;
34141   return jresult;
34142 }
34143
34144
34145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34146   void * jresult ;
34147   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34148   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34149
34150   arg1 = (Dali::Stage *)jarg1;
34151   {
34152     try {
34153       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34154     } catch (std::out_of_range& e) {
34155       {
34156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34157       };
34158     } catch (std::exception& e) {
34159       {
34160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34161       };
34162     } catch (...) {
34163       {
34164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34165       };
34166     }
34167   }
34168   jresult = (void *)result;
34169   return jresult;
34170 }
34171
34172
34173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34174   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34175
34176   arg1 = (Dali::RelayoutContainer *)jarg1;
34177   {
34178     try {
34179       delete arg1;
34180     } catch (std::out_of_range& e) {
34181       {
34182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34183       };
34184     } catch (std::exception& e) {
34185       {
34186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34187       };
34188     } catch (...) {
34189       {
34190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34191       };
34192     }
34193   }
34194 }
34195
34196
34197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34198   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34199   Dali::Actor *arg2 = 0 ;
34200   Dali::Vector2 *arg3 = 0 ;
34201
34202   arg1 = (Dali::RelayoutContainer *)jarg1;
34203   arg2 = (Dali::Actor *)jarg2;
34204   if (!arg2) {
34205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34206     return ;
34207   }
34208   arg3 = (Dali::Vector2 *)jarg3;
34209   if (!arg3) {
34210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34211     return ;
34212   }
34213   {
34214     try {
34215       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34216     } catch (std::out_of_range& e) {
34217       {
34218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34219       };
34220     } catch (std::exception& e) {
34221       {
34222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34223       };
34224     } catch (...) {
34225       {
34226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34227       };
34228     }
34229   }
34230 }
34231
34232
34233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34234   void * jresult ;
34235   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34236   Dali::CustomActor result;
34237
34238   arg1 = (Dali::CustomActorImpl *)jarg1;
34239   {
34240     try {
34241       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34242     } catch (std::out_of_range& e) {
34243       {
34244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34245       };
34246     } catch (std::exception& e) {
34247       {
34248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34253       };
34254     }
34255   }
34256   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34257   return jresult;
34258 }
34259
34260
34261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34262   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34263   int arg2 ;
34264
34265   arg1 = (Dali::CustomActorImpl *)jarg1;
34266   arg2 = (int)jarg2;
34267   {
34268     try {
34269       (arg1)->OnStageConnection(arg2);
34270     } catch (std::out_of_range& e) {
34271       {
34272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34273       };
34274     } catch (std::exception& e) {
34275       {
34276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34277       };
34278     } catch (...) {
34279       {
34280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34281       };
34282     }
34283   }
34284 }
34285
34286
34287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34288   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34289
34290   arg1 = (Dali::CustomActorImpl *)jarg1;
34291   {
34292     try {
34293       (arg1)->OnStageDisconnection();
34294     } catch (std::out_of_range& e) {
34295       {
34296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34297       };
34298     } catch (std::exception& e) {
34299       {
34300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34301       };
34302     } catch (...) {
34303       {
34304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34305       };
34306     }
34307   }
34308 }
34309
34310
34311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34312   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34313   Dali::Actor *arg2 = 0 ;
34314
34315   arg1 = (Dali::CustomActorImpl *)jarg1;
34316   arg2 = (Dali::Actor *)jarg2;
34317   if (!arg2) {
34318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34319     return ;
34320   }
34321   {
34322     try {
34323       (arg1)->OnChildAdd(*arg2);
34324     } catch (std::out_of_range& e) {
34325       {
34326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34327       };
34328     } catch (std::exception& e) {
34329       {
34330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34331       };
34332     } catch (...) {
34333       {
34334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34335       };
34336     }
34337   }
34338 }
34339
34340
34341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34342   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34343   Dali::Actor *arg2 = 0 ;
34344
34345   arg1 = (Dali::CustomActorImpl *)jarg1;
34346   arg2 = (Dali::Actor *)jarg2;
34347   if (!arg2) {
34348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34349     return ;
34350   }
34351   {
34352     try {
34353       (arg1)->OnChildRemove(*arg2);
34354     } catch (std::out_of_range& e) {
34355       {
34356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34357       };
34358     } catch (std::exception& e) {
34359       {
34360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34361       };
34362     } catch (...) {
34363       {
34364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34365       };
34366     }
34367   }
34368 }
34369
34370
34371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34372   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34373   Dali::Property::Index arg2 ;
34374   Dali::Property::Value arg3 ;
34375   Dali::Property::Value *argp3 ;
34376
34377   arg1 = (Dali::CustomActorImpl *)jarg1;
34378   arg2 = (Dali::Property::Index)jarg2;
34379   argp3 = (Dali::Property::Value *)jarg3;
34380   if (!argp3) {
34381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34382     return ;
34383   }
34384   arg3 = *argp3;
34385   {
34386     try {
34387       (arg1)->OnPropertySet(arg2,arg3);
34388     } catch (std::out_of_range& e) {
34389       {
34390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34391       };
34392     } catch (std::exception& e) {
34393       {
34394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34395       };
34396     } catch (...) {
34397       {
34398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34399       };
34400     }
34401   }
34402 }
34403
34404
34405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34407   Dali::Vector3 *arg2 = 0 ;
34408
34409   arg1 = (Dali::CustomActorImpl *)jarg1;
34410   arg2 = (Dali::Vector3 *)jarg2;
34411   if (!arg2) {
34412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34413     return ;
34414   }
34415   {
34416     try {
34417       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34418     } catch (std::out_of_range& e) {
34419       {
34420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34421       };
34422     } catch (std::exception& e) {
34423       {
34424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34425       };
34426     } catch (...) {
34427       {
34428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34429       };
34430     }
34431   }
34432 }
34433
34434
34435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34436   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34437   Dali::Animation *arg2 = 0 ;
34438   Dali::Vector3 *arg3 = 0 ;
34439
34440   arg1 = (Dali::CustomActorImpl *)jarg1;
34441   arg2 = (Dali::Animation *)jarg2;
34442   if (!arg2) {
34443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34444     return ;
34445   }
34446   arg3 = (Dali::Vector3 *)jarg3;
34447   if (!arg3) {
34448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34449     return ;
34450   }
34451   {
34452     try {
34453       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34454     } catch (std::out_of_range& e) {
34455       {
34456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34457       };
34458     } catch (std::exception& e) {
34459       {
34460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34461       };
34462     } catch (...) {
34463       {
34464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34465       };
34466     }
34467   }
34468 }
34469
34470
34471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34472   unsigned int jresult ;
34473   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34474   Dali::TouchEvent *arg2 = 0 ;
34475   bool result;
34476
34477   arg1 = (Dali::CustomActorImpl *)jarg1;
34478   arg2 = (Dali::TouchEvent *)jarg2;
34479   if (!arg2) {
34480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34481     return 0;
34482   }
34483   {
34484     try {
34485       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34486     } catch (std::out_of_range& e) {
34487       {
34488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34489       };
34490     } catch (std::exception& e) {
34491       {
34492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34493       };
34494     } catch (...) {
34495       {
34496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34497       };
34498     }
34499   }
34500   jresult = result;
34501   return jresult;
34502 }
34503
34504
34505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34506   unsigned int jresult ;
34507   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34508   Dali::HoverEvent *arg2 = 0 ;
34509   bool result;
34510
34511   arg1 = (Dali::CustomActorImpl *)jarg1;
34512   arg2 = (Dali::HoverEvent *)jarg2;
34513   if (!arg2) {
34514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34515     return 0;
34516   }
34517   {
34518     try {
34519       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34520     } catch (std::out_of_range& e) {
34521       {
34522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34523       };
34524     } catch (std::exception& e) {
34525       {
34526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34527       };
34528     } catch (...) {
34529       {
34530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34531       };
34532     }
34533   }
34534   jresult = result;
34535   return jresult;
34536 }
34537
34538
34539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34540   unsigned int jresult ;
34541   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34542   Dali::KeyEvent *arg2 = 0 ;
34543   bool result;
34544
34545   arg1 = (Dali::CustomActorImpl *)jarg1;
34546   arg2 = (Dali::KeyEvent *)jarg2;
34547   if (!arg2) {
34548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34549     return 0;
34550   }
34551   {
34552     try {
34553       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34554     } catch (std::out_of_range& e) {
34555       {
34556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34557       };
34558     } catch (std::exception& e) {
34559       {
34560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34561       };
34562     } catch (...) {
34563       {
34564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34565       };
34566     }
34567   }
34568   jresult = result;
34569   return jresult;
34570 }
34571
34572
34573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34574   unsigned int jresult ;
34575   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34576   Dali::WheelEvent *arg2 = 0 ;
34577   bool result;
34578
34579   arg1 = (Dali::CustomActorImpl *)jarg1;
34580   arg2 = (Dali::WheelEvent *)jarg2;
34581   if (!arg2) {
34582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34583     return 0;
34584   }
34585   {
34586     try {
34587       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34588     } catch (std::out_of_range& e) {
34589       {
34590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34591       };
34592     } catch (std::exception& e) {
34593       {
34594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34595       };
34596     } catch (...) {
34597       {
34598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34599       };
34600     }
34601   }
34602   jresult = result;
34603   return jresult;
34604 }
34605
34606
34607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34609   Dali::Vector2 *arg2 = 0 ;
34610   Dali::RelayoutContainer *arg3 = 0 ;
34611
34612   arg1 = (Dali::CustomActorImpl *)jarg1;
34613   arg2 = (Dali::Vector2 *)jarg2;
34614   if (!arg2) {
34615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34616     return ;
34617   }
34618   arg3 = (Dali::RelayoutContainer *)jarg3;
34619   if (!arg3) {
34620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34621     return ;
34622   }
34623   {
34624     try {
34625       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34626     } catch (std::out_of_range& e) {
34627       {
34628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34629       };
34630     } catch (std::exception& e) {
34631       {
34632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (...) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34637       };
34638     }
34639   }
34640 }
34641
34642
34643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34645   Dali::ResizePolicy::Type arg2 ;
34646   Dali::Dimension::Type arg3 ;
34647
34648   arg1 = (Dali::CustomActorImpl *)jarg1;
34649   arg2 = (Dali::ResizePolicy::Type)jarg2;
34650   arg3 = (Dali::Dimension::Type)jarg3;
34651   {
34652     try {
34653       (arg1)->OnSetResizePolicy(arg2,arg3);
34654     } catch (std::out_of_range& e) {
34655       {
34656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34657       };
34658     } catch (std::exception& e) {
34659       {
34660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34661       };
34662     } catch (...) {
34663       {
34664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34665       };
34666     }
34667   }
34668 }
34669
34670
34671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34672   void * jresult ;
34673   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34674   Dali::Vector3 result;
34675
34676   arg1 = (Dali::CustomActorImpl *)jarg1;
34677   {
34678     try {
34679       result = (arg1)->GetNaturalSize();
34680     } catch (std::out_of_range& e) {
34681       {
34682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34683       };
34684     } catch (std::exception& e) {
34685       {
34686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34687       };
34688     } catch (...) {
34689       {
34690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34691       };
34692     }
34693   }
34694   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34695   return jresult;
34696 }
34697
34698
34699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34700   float jresult ;
34701   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34702   Dali::Actor *arg2 = 0 ;
34703   Dali::Dimension::Type arg3 ;
34704   float result;
34705
34706   arg1 = (Dali::CustomActorImpl *)jarg1;
34707   arg2 = (Dali::Actor *)jarg2;
34708   if (!arg2) {
34709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34710     return 0;
34711   }
34712   arg3 = (Dali::Dimension::Type)jarg3;
34713   {
34714     try {
34715       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34716     } catch (std::out_of_range& e) {
34717       {
34718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34719       };
34720     } catch (std::exception& e) {
34721       {
34722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34723       };
34724     } catch (...) {
34725       {
34726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34727       };
34728     }
34729   }
34730   jresult = result;
34731   return jresult;
34732 }
34733
34734
34735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34736   float jresult ;
34737   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34738   float arg2 ;
34739   float result;
34740
34741   arg1 = (Dali::CustomActorImpl *)jarg1;
34742   arg2 = (float)jarg2;
34743   {
34744     try {
34745       result = (float)(arg1)->GetHeightForWidth(arg2);
34746     } catch (std::out_of_range& e) {
34747       {
34748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34749       };
34750     } catch (std::exception& e) {
34751       {
34752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34753       };
34754     } catch (...) {
34755       {
34756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34757       };
34758     }
34759   }
34760   jresult = result;
34761   return jresult;
34762 }
34763
34764
34765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34766   float jresult ;
34767   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34768   float arg2 ;
34769   float result;
34770
34771   arg1 = (Dali::CustomActorImpl *)jarg1;
34772   arg2 = (float)jarg2;
34773   {
34774     try {
34775       result = (float)(arg1)->GetWidthForHeight(arg2);
34776     } catch (std::out_of_range& e) {
34777       {
34778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34779       };
34780     } catch (std::exception& e) {
34781       {
34782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34783       };
34784     } catch (...) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34787       };
34788     }
34789   }
34790   jresult = result;
34791   return jresult;
34792 }
34793
34794
34795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34796   unsigned int jresult ;
34797   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34798   Dali::Dimension::Type arg2 ;
34799   bool result;
34800
34801   arg1 = (Dali::CustomActorImpl *)jarg1;
34802   arg2 = (Dali::Dimension::Type)jarg2;
34803   {
34804     try {
34805       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34806     } catch (std::out_of_range& e) {
34807       {
34808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34809       };
34810     } catch (std::exception& e) {
34811       {
34812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34813       };
34814     } catch (...) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34817       };
34818     }
34819   }
34820   jresult = result;
34821   return jresult;
34822 }
34823
34824
34825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34826   unsigned int jresult ;
34827   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34828   bool result;
34829
34830   arg1 = (Dali::CustomActorImpl *)jarg1;
34831   {
34832     try {
34833       result = (bool)(arg1)->RelayoutDependentOnChildren();
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34841       };
34842     } catch (...) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34845       };
34846     }
34847   }
34848   jresult = result;
34849   return jresult;
34850 }
34851
34852
34853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34854   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34855   Dali::Dimension::Type arg2 ;
34856
34857   arg1 = (Dali::CustomActorImpl *)jarg1;
34858   arg2 = (Dali::Dimension::Type)jarg2;
34859   {
34860     try {
34861       (arg1)->OnCalculateRelayoutSize(arg2);
34862     } catch (std::out_of_range& e) {
34863       {
34864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34865       };
34866     } catch (std::exception& e) {
34867       {
34868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34873       };
34874     }
34875   }
34876 }
34877
34878
34879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34880   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34881   float arg2 ;
34882   Dali::Dimension::Type arg3 ;
34883
34884   arg1 = (Dali::CustomActorImpl *)jarg1;
34885   arg2 = (float)jarg2;
34886   arg3 = (Dali::Dimension::Type)jarg3;
34887   {
34888     try {
34889       (arg1)->OnLayoutNegotiated(arg2,arg3);
34890     } catch (std::out_of_range& e) {
34891       {
34892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34893       };
34894     } catch (std::exception& e) {
34895       {
34896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34897       };
34898     } catch (...) {
34899       {
34900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34901       };
34902     }
34903   }
34904 }
34905
34906
34907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34908   unsigned int jresult ;
34909   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34910   bool result;
34911
34912   arg1 = (Dali::CustomActorImpl *)jarg1;
34913   {
34914     try {
34915       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34916     } catch (std::out_of_range& e) {
34917       {
34918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34919       };
34920     } catch (std::exception& e) {
34921       {
34922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34923       };
34924     } catch (...) {
34925       {
34926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34927       };
34928     }
34929   }
34930   jresult = result;
34931   return jresult;
34932 }
34933
34934
34935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34936   unsigned int jresult ;
34937   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34938   bool result;
34939
34940   arg1 = (Dali::CustomActorImpl *)jarg1;
34941   {
34942     try {
34943       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34944     } catch (std::out_of_range& e) {
34945       {
34946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34947       };
34948     } catch (std::exception& e) {
34949       {
34950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34951       };
34952     } catch (...) {
34953       {
34954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34955       };
34956     }
34957   }
34958   jresult = result;
34959   return jresult;
34960 }
34961
34962
34963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34964   unsigned int jresult ;
34965   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34966   bool result;
34967
34968   arg1 = (Dali::CustomActorImpl *)jarg1;
34969   {
34970     try {
34971       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34972     } catch (std::out_of_range& e) {
34973       {
34974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34975       };
34976     } catch (std::exception& e) {
34977       {
34978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34979       };
34980     } catch (...) {
34981       {
34982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34983       };
34984     }
34985   }
34986   jresult = result;
34987   return jresult;
34988 }
34989
34990
34991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34992   unsigned int jresult ;
34993   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34994   bool result;
34995
34996   arg1 = (Dali::CustomActorImpl *)jarg1;
34997   {
34998     try {
34999       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
35000     } catch (std::out_of_range& e) {
35001       {
35002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35003       };
35004     } catch (std::exception& e) {
35005       {
35006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35007       };
35008     } catch (...) {
35009       {
35010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35011       };
35012     }
35013   }
35014   jresult = result;
35015   return jresult;
35016 }
35017
35018
35019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
35020   void * jresult ;
35021   Dali::CustomActor *result = 0 ;
35022
35023   {
35024     try {
35025       result = (Dali::CustomActor *)new Dali::CustomActor();
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35033       };
35034     } catch (...) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35037       };
35038     }
35039   }
35040   jresult = (void *)result;
35041   return jresult;
35042 }
35043
35044
35045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35046   void * jresult ;
35047   Dali::BaseHandle arg1 ;
35048   Dali::BaseHandle *argp1 ;
35049   Dali::CustomActor result;
35050
35051   argp1 = (Dali::BaseHandle *)jarg1;
35052   if (!argp1) {
35053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35054     return 0;
35055   }
35056   arg1 = *argp1;
35057   {
35058     try {
35059       result = Dali::CustomActor::DownCast(arg1);
35060     } catch (std::out_of_range& e) {
35061       {
35062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35063       };
35064     } catch (std::exception& e) {
35065       {
35066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35067       };
35068     } catch (...) {
35069       {
35070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35071       };
35072     }
35073   }
35074   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35075   return jresult;
35076 }
35077
35078
35079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35080   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35081
35082   arg1 = (Dali::CustomActor *)jarg1;
35083   {
35084     try {
35085       delete arg1;
35086     } catch (std::out_of_range& e) {
35087       {
35088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35089       };
35090     } catch (std::exception& e) {
35091       {
35092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35093       };
35094     } catch (...) {
35095       {
35096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35097       };
35098     }
35099   }
35100 }
35101
35102
35103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35104   void * jresult ;
35105   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35106   Dali::CustomActorImpl *result = 0 ;
35107
35108   arg1 = (Dali::CustomActor *)jarg1;
35109   {
35110     try {
35111       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35112     } catch (std::out_of_range& e) {
35113       {
35114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35115       };
35116     } catch (std::exception& e) {
35117       {
35118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35119       };
35120     } catch (...) {
35121       {
35122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35123       };
35124     }
35125   }
35126   jresult = (void *)result;
35127   return jresult;
35128 }
35129
35130
35131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35132   void * jresult ;
35133   Dali::CustomActorImpl *arg1 = 0 ;
35134   Dali::CustomActor *result = 0 ;
35135
35136   arg1 = (Dali::CustomActorImpl *)jarg1;
35137   if (!arg1) {
35138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35139     return 0;
35140   }
35141   {
35142     try {
35143       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35144     } catch (std::out_of_range& e) {
35145       {
35146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35147       };
35148     } catch (std::exception& e) {
35149       {
35150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35151       };
35152     } catch (...) {
35153       {
35154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35155       };
35156     }
35157   }
35158   jresult = (void *)result;
35159   return jresult;
35160 }
35161
35162
35163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35164   void * jresult ;
35165   Dali::CustomActor *arg1 = 0 ;
35166   Dali::CustomActor *result = 0 ;
35167
35168   arg1 = (Dali::CustomActor *)jarg1;
35169   if (!arg1) {
35170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35171     return 0;
35172   }
35173   {
35174     try {
35175       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35176     } catch (std::out_of_range& e) {
35177       {
35178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35179       };
35180     } catch (std::exception& e) {
35181       {
35182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35183       };
35184     } catch (...) {
35185       {
35186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35187       };
35188     }
35189   }
35190   jresult = (void *)result;
35191   return jresult;
35192 }
35193
35194
35195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35196   void * jresult ;
35197   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35198   Dali::CustomActor *arg2 = 0 ;
35199   Dali::CustomActor *result = 0 ;
35200
35201   arg1 = (Dali::CustomActor *)jarg1;
35202   arg2 = (Dali::CustomActor *)jarg2;
35203   if (!arg2) {
35204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35205     return 0;
35206   }
35207   {
35208     try {
35209       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35210     } catch (std::out_of_range& e) {
35211       {
35212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35213       };
35214     } catch (std::exception& e) {
35215       {
35216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35217       };
35218     } catch (...) {
35219       {
35220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35221       };
35222     }
35223   }
35224   jresult = (void *)result;
35225   return jresult;
35226 }
35227
35228
35229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35230   int jresult ;
35231   int result;
35232
35233   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35234   jresult = (int)result;
35235   return jresult;
35236 }
35237
35238
35239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35240   int jresult ;
35241   int result;
35242
35243   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35244   jresult = (int)result;
35245   return jresult;
35246 }
35247
35248
35249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35250   int jresult ;
35251   int result;
35252
35253   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35254   jresult = (int)result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35260   int jresult ;
35261   int result;
35262
35263   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35264   jresult = (int)result;
35265   return jresult;
35266 }
35267
35268
35269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35270   int jresult ;
35271   int result;
35272
35273   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35274   jresult = (int)result;
35275   return jresult;
35276 }
35277
35278
35279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35280   int jresult ;
35281   int result;
35282
35283   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35284   jresult = (int)result;
35285   return jresult;
35286 }
35287
35288
35289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35290   int jresult ;
35291   int result;
35292
35293   result = (int)Dali::PanGestureDetector::Property::PANNING;
35294   jresult = (int)result;
35295   return jresult;
35296 }
35297
35298
35299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35300   void * jresult ;
35301   Dali::PanGestureDetector::Property *result = 0 ;
35302
35303   {
35304     try {
35305       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35306     } catch (std::out_of_range& e) {
35307       {
35308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35309       };
35310     } catch (std::exception& e) {
35311       {
35312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35317       };
35318     }
35319   }
35320   jresult = (void *)result;
35321   return jresult;
35322 }
35323
35324
35325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35326   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35327
35328   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35329   {
35330     try {
35331       delete arg1;
35332     } catch (std::out_of_range& e) {
35333       {
35334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35335       };
35336     } catch (std::exception& e) {
35337       {
35338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (...) {
35341       {
35342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35343       };
35344     }
35345   }
35346 }
35347
35348
35349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35350   void * jresult ;
35351   Dali::Radian *result = 0 ;
35352
35353   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35354   jresult = (void *)result;
35355   return jresult;
35356 }
35357
35358
35359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35360   void * jresult ;
35361   Dali::Radian *result = 0 ;
35362
35363   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35364   jresult = (void *)result;
35365   return jresult;
35366 }
35367
35368
35369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35370   void * jresult ;
35371   Dali::Radian *result = 0 ;
35372
35373   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35374   jresult = (void *)result;
35375   return jresult;
35376 }
35377
35378
35379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35380   void * jresult ;
35381   Dali::Radian *result = 0 ;
35382
35383   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35384   jresult = (void *)result;
35385   return jresult;
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35390   void * jresult ;
35391   Dali::Radian *result = 0 ;
35392
35393   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35394   jresult = (void *)result;
35395   return jresult;
35396 }
35397
35398
35399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35400   void * jresult ;
35401   Dali::Radian *result = 0 ;
35402
35403   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35404   jresult = (void *)result;
35405   return jresult;
35406 }
35407
35408
35409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35410   void * jresult ;
35411   Dali::Radian *result = 0 ;
35412
35413   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35414   jresult = (void *)result;
35415   return jresult;
35416 }
35417
35418
35419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35420   void * jresult ;
35421   Dali::PanGestureDetector *result = 0 ;
35422
35423   {
35424     try {
35425       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35426     } catch (std::out_of_range& e) {
35427       {
35428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35429       };
35430     } catch (std::exception& e) {
35431       {
35432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35433       };
35434     } catch (...) {
35435       {
35436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35437       };
35438     }
35439   }
35440   jresult = (void *)result;
35441   return jresult;
35442 }
35443
35444
35445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35446   void * jresult ;
35447   Dali::PanGestureDetector result;
35448
35449   {
35450     try {
35451       result = Dali::PanGestureDetector::New();
35452     } catch (std::out_of_range& e) {
35453       {
35454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35455       };
35456     } catch (std::exception& e) {
35457       {
35458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35459       };
35460     } catch (...) {
35461       {
35462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35463       };
35464     }
35465   }
35466   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35467   return jresult;
35468 }
35469
35470
35471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35472   void * jresult ;
35473   Dali::BaseHandle arg1 ;
35474   Dali::BaseHandle *argp1 ;
35475   Dali::PanGestureDetector result;
35476
35477   argp1 = (Dali::BaseHandle *)jarg1;
35478   if (!argp1) {
35479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35480     return 0;
35481   }
35482   arg1 = *argp1;
35483   {
35484     try {
35485       result = Dali::PanGestureDetector::DownCast(arg1);
35486     } catch (std::out_of_range& e) {
35487       {
35488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35489       };
35490     } catch (std::exception& e) {
35491       {
35492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35493       };
35494     } catch (...) {
35495       {
35496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35497       };
35498     }
35499   }
35500   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35501   return jresult;
35502 }
35503
35504
35505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35506   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35507
35508   arg1 = (Dali::PanGestureDetector *)jarg1;
35509   {
35510     try {
35511       delete arg1;
35512     } catch (std::out_of_range& e) {
35513       {
35514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35515       };
35516     } catch (std::exception& e) {
35517       {
35518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35519       };
35520     } catch (...) {
35521       {
35522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35523       };
35524     }
35525   }
35526 }
35527
35528
35529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35530   void * jresult ;
35531   Dali::PanGestureDetector *arg1 = 0 ;
35532   Dali::PanGestureDetector *result = 0 ;
35533
35534   arg1 = (Dali::PanGestureDetector *)jarg1;
35535   if (!arg1) {
35536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35537     return 0;
35538   }
35539   {
35540     try {
35541       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35542     } catch (std::out_of_range& e) {
35543       {
35544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35545       };
35546     } catch (std::exception& e) {
35547       {
35548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35549       };
35550     } catch (...) {
35551       {
35552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35553       };
35554     }
35555   }
35556   jresult = (void *)result;
35557   return jresult;
35558 }
35559
35560
35561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35562   void * jresult ;
35563   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35564   Dali::PanGestureDetector *arg2 = 0 ;
35565   Dali::PanGestureDetector *result = 0 ;
35566
35567   arg1 = (Dali::PanGestureDetector *)jarg1;
35568   arg2 = (Dali::PanGestureDetector *)jarg2;
35569   if (!arg2) {
35570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35571     return 0;
35572   }
35573   {
35574     try {
35575       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35576     } catch (std::out_of_range& e) {
35577       {
35578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35579       };
35580     } catch (std::exception& e) {
35581       {
35582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35583       };
35584     } catch (...) {
35585       {
35586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35587       };
35588     }
35589   }
35590   jresult = (void *)result;
35591   return jresult;
35592 }
35593
35594
35595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35596   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35597   unsigned int arg2 ;
35598
35599   arg1 = (Dali::PanGestureDetector *)jarg1;
35600   arg2 = (unsigned int)jarg2;
35601   {
35602     try {
35603       (arg1)->SetMinimumTouchesRequired(arg2);
35604     } catch (std::out_of_range& e) {
35605       {
35606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35607       };
35608     } catch (std::exception& e) {
35609       {
35610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35611       };
35612     } catch (...) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35615       };
35616     }
35617   }
35618 }
35619
35620
35621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35622   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35623   unsigned int arg2 ;
35624
35625   arg1 = (Dali::PanGestureDetector *)jarg1;
35626   arg2 = (unsigned int)jarg2;
35627   {
35628     try {
35629       (arg1)->SetMaximumTouchesRequired(arg2);
35630     } catch (std::out_of_range& e) {
35631       {
35632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (std::exception& e) {
35635       {
35636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35637       };
35638     } catch (...) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35641       };
35642     }
35643   }
35644 }
35645
35646
35647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35648   unsigned int jresult ;
35649   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35650   unsigned int result;
35651
35652   arg1 = (Dali::PanGestureDetector *)jarg1;
35653   {
35654     try {
35655       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35656     } catch (std::out_of_range& e) {
35657       {
35658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35659       };
35660     } catch (std::exception& e) {
35661       {
35662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (...) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35667       };
35668     }
35669   }
35670   jresult = result;
35671   return jresult;
35672 }
35673
35674
35675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35676   unsigned int jresult ;
35677   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35678   unsigned int result;
35679
35680   arg1 = (Dali::PanGestureDetector *)jarg1;
35681   {
35682     try {
35683       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35684     } catch (std::out_of_range& e) {
35685       {
35686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35687       };
35688     } catch (std::exception& e) {
35689       {
35690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35691       };
35692     } catch (...) {
35693       {
35694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35695       };
35696     }
35697   }
35698   jresult = result;
35699   return jresult;
35700 }
35701
35702
35703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35704   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35705   Dali::Radian arg2 ;
35706   Dali::Radian arg3 ;
35707   Dali::Radian *argp2 ;
35708   Dali::Radian *argp3 ;
35709
35710   arg1 = (Dali::PanGestureDetector *)jarg1;
35711   argp2 = (Dali::Radian *)jarg2;
35712   if (!argp2) {
35713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35714     return ;
35715   }
35716   arg2 = *argp2;
35717   argp3 = (Dali::Radian *)jarg3;
35718   if (!argp3) {
35719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35720     return ;
35721   }
35722   arg3 = *argp3;
35723   {
35724     try {
35725       (arg1)->AddAngle(arg2,arg3);
35726     } catch (std::out_of_range& e) {
35727       {
35728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35729       };
35730     } catch (std::exception& e) {
35731       {
35732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35733       };
35734     } catch (...) {
35735       {
35736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35737       };
35738     }
35739   }
35740 }
35741
35742
35743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35744   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35745   Dali::Radian arg2 ;
35746   Dali::Radian *argp2 ;
35747
35748   arg1 = (Dali::PanGestureDetector *)jarg1;
35749   argp2 = (Dali::Radian *)jarg2;
35750   if (!argp2) {
35751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35752     return ;
35753   }
35754   arg2 = *argp2;
35755   {
35756     try {
35757       (arg1)->AddAngle(arg2);
35758     } catch (std::out_of_range& e) {
35759       {
35760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35761       };
35762     } catch (std::exception& e) {
35763       {
35764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35765       };
35766     } catch (...) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35769       };
35770     }
35771   }
35772 }
35773
35774
35775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35776   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35777   Dali::Radian arg2 ;
35778   Dali::Radian arg3 ;
35779   Dali::Radian *argp2 ;
35780   Dali::Radian *argp3 ;
35781
35782   arg1 = (Dali::PanGestureDetector *)jarg1;
35783   argp2 = (Dali::Radian *)jarg2;
35784   if (!argp2) {
35785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35786     return ;
35787   }
35788   arg2 = *argp2;
35789   argp3 = (Dali::Radian *)jarg3;
35790   if (!argp3) {
35791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35792     return ;
35793   }
35794   arg3 = *argp3;
35795   {
35796     try {
35797       (arg1)->AddDirection(arg2,arg3);
35798     } catch (std::out_of_range& e) {
35799       {
35800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35801       };
35802     } catch (std::exception& e) {
35803       {
35804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35805       };
35806     } catch (...) {
35807       {
35808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35809       };
35810     }
35811   }
35812 }
35813
35814
35815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35816   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35817   Dali::Radian arg2 ;
35818   Dali::Radian *argp2 ;
35819
35820   arg1 = (Dali::PanGestureDetector *)jarg1;
35821   argp2 = (Dali::Radian *)jarg2;
35822   if (!argp2) {
35823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35824     return ;
35825   }
35826   arg2 = *argp2;
35827   {
35828     try {
35829       (arg1)->AddDirection(arg2);
35830     } catch (std::out_of_range& e) {
35831       {
35832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35833       };
35834     } catch (std::exception& e) {
35835       {
35836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35841       };
35842     }
35843   }
35844 }
35845
35846
35847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35848   unsigned long jresult ;
35849   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35850   size_t result;
35851
35852   arg1 = (Dali::PanGestureDetector *)jarg1;
35853   {
35854     try {
35855       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35856     } catch (std::out_of_range& e) {
35857       {
35858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35859       };
35860     } catch (std::exception& e) {
35861       {
35862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35863       };
35864     } catch (...) {
35865       {
35866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35867       };
35868     }
35869   }
35870   jresult = (unsigned long)result;
35871   return jresult;
35872 }
35873
35874
35875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35876   void * jresult ;
35877   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35878   size_t arg2 ;
35879   Dali::PanGestureDetector::AngleThresholdPair result;
35880
35881   arg1 = (Dali::PanGestureDetector *)jarg1;
35882   arg2 = (size_t)jarg2;
35883   {
35884     try {
35885       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35886     } catch (std::out_of_range& e) {
35887       {
35888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35889       };
35890     } catch (std::exception& e) {
35891       {
35892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (...) {
35895       {
35896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35897       };
35898     }
35899   }
35900   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35901   return jresult;
35902 }
35903
35904
35905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35906   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35907
35908   arg1 = (Dali::PanGestureDetector *)jarg1;
35909   {
35910     try {
35911       (arg1)->ClearAngles();
35912     } catch (std::out_of_range& e) {
35913       {
35914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35915       };
35916     } catch (std::exception& e) {
35917       {
35918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35919       };
35920     } catch (...) {
35921       {
35922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35923       };
35924     }
35925   }
35926 }
35927
35928
35929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35930   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35931   Dali::Radian arg2 ;
35932   Dali::Radian *argp2 ;
35933
35934   arg1 = (Dali::PanGestureDetector *)jarg1;
35935   argp2 = (Dali::Radian *)jarg2;
35936   if (!argp2) {
35937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35938     return ;
35939   }
35940   arg2 = *argp2;
35941   {
35942     try {
35943       (arg1)->RemoveAngle(arg2);
35944     } catch (std::out_of_range& e) {
35945       {
35946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35947       };
35948     } catch (std::exception& e) {
35949       {
35950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35951       };
35952     } catch (...) {
35953       {
35954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35955       };
35956     }
35957   }
35958 }
35959
35960
35961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35962   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35963   Dali::Radian arg2 ;
35964   Dali::Radian *argp2 ;
35965
35966   arg1 = (Dali::PanGestureDetector *)jarg1;
35967   argp2 = (Dali::Radian *)jarg2;
35968   if (!argp2) {
35969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35970     return ;
35971   }
35972   arg2 = *argp2;
35973   {
35974     try {
35975       (arg1)->RemoveDirection(arg2);
35976     } catch (std::out_of_range& e) {
35977       {
35978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35979       };
35980     } catch (std::exception& e) {
35981       {
35982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35983       };
35984     } catch (...) {
35985       {
35986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35987       };
35988     }
35989   }
35990 }
35991
35992
35993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35994   void * jresult ;
35995   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35996   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35997
35998   arg1 = (Dali::PanGestureDetector *)jarg1;
35999   {
36000     try {
36001       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36002     } catch (std::out_of_range& e) {
36003       {
36004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36005       };
36006     } catch (std::exception& e) {
36007       {
36008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36009       };
36010     } catch (...) {
36011       {
36012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36013       };
36014     }
36015   }
36016   jresult = (void *)result;
36017   return jresult;
36018 }
36019
36020
36021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36022   Dali::PanGesture *arg1 = 0 ;
36023
36024   arg1 = (Dali::PanGesture *)jarg1;
36025   if (!arg1) {
36026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36027     return ;
36028   }
36029   {
36030     try {
36031       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36032     } catch (std::out_of_range& e) {
36033       {
36034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36035       };
36036     } catch (std::exception& e) {
36037       {
36038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36039       };
36040     } catch (...) {
36041       {
36042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36043       };
36044     }
36045   }
36046 }
36047
36048
36049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36050   void * jresult ;
36051   Dali::PanGesture *result = 0 ;
36052
36053   {
36054     try {
36055       result = (Dali::PanGesture *)new Dali::PanGesture();
36056     } catch (std::out_of_range& e) {
36057       {
36058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36059       };
36060     } catch (std::exception& e) {
36061       {
36062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36063       };
36064     } catch (...) {
36065       {
36066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36067       };
36068     }
36069   }
36070   jresult = (void *)result;
36071   return jresult;
36072 }
36073
36074
36075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36076   void * jresult ;
36077   Dali::Gesture::State arg1 ;
36078   Dali::PanGesture *result = 0 ;
36079
36080   arg1 = (Dali::Gesture::State)jarg1;
36081   {
36082     try {
36083       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36084     } catch (std::out_of_range& e) {
36085       {
36086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36087       };
36088     } catch (std::exception& e) {
36089       {
36090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36091       };
36092     } catch (...) {
36093       {
36094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36095       };
36096     }
36097   }
36098   jresult = (void *)result;
36099   return jresult;
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36104   void * jresult ;
36105   Dali::PanGesture *arg1 = 0 ;
36106   Dali::PanGesture *result = 0 ;
36107
36108   arg1 = (Dali::PanGesture *)jarg1;
36109   if (!arg1) {
36110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36111     return 0;
36112   }
36113   {
36114     try {
36115       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36116     } catch (std::out_of_range& e) {
36117       {
36118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36119       };
36120     } catch (std::exception& e) {
36121       {
36122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36123       };
36124     } catch (...) {
36125       {
36126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36127       };
36128     }
36129   }
36130   jresult = (void *)result;
36131   return jresult;
36132 }
36133
36134
36135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36136   void * jresult ;
36137   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36138   Dali::PanGesture *arg2 = 0 ;
36139   Dali::PanGesture *result = 0 ;
36140
36141   arg1 = (Dali::PanGesture *)jarg1;
36142   arg2 = (Dali::PanGesture *)jarg2;
36143   if (!arg2) {
36144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36145     return 0;
36146   }
36147   {
36148     try {
36149       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36150     } catch (std::out_of_range& e) {
36151       {
36152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36153       };
36154     } catch (std::exception& e) {
36155       {
36156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36157       };
36158     } catch (...) {
36159       {
36160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36161       };
36162     }
36163   }
36164   jresult = (void *)result;
36165   return jresult;
36166 }
36167
36168
36169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36170   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36171
36172   arg1 = (Dali::PanGesture *)jarg1;
36173   {
36174     try {
36175       delete arg1;
36176     } catch (std::out_of_range& e) {
36177       {
36178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36179       };
36180     } catch (std::exception& e) {
36181       {
36182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36183       };
36184     } catch (...) {
36185       {
36186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36187       };
36188     }
36189   }
36190 }
36191
36192
36193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36194   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36195   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36196
36197   arg1 = (Dali::PanGesture *)jarg1;
36198   arg2 = (Dali::Vector2 *)jarg2;
36199   if (arg1) (arg1)->velocity = *arg2;
36200 }
36201
36202
36203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36204   void * jresult ;
36205   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36206   Dali::Vector2 *result = 0 ;
36207
36208   arg1 = (Dali::PanGesture *)jarg1;
36209   result = (Dali::Vector2 *)& ((arg1)->velocity);
36210   jresult = (void *)result;
36211   return jresult;
36212 }
36213
36214
36215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36216   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36217   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36218
36219   arg1 = (Dali::PanGesture *)jarg1;
36220   arg2 = (Dali::Vector2 *)jarg2;
36221   if (arg1) (arg1)->displacement = *arg2;
36222 }
36223
36224
36225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36226   void * jresult ;
36227   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36228   Dali::Vector2 *result = 0 ;
36229
36230   arg1 = (Dali::PanGesture *)jarg1;
36231   result = (Dali::Vector2 *)& ((arg1)->displacement);
36232   jresult = (void *)result;
36233   return jresult;
36234 }
36235
36236
36237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36238   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36239   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36240
36241   arg1 = (Dali::PanGesture *)jarg1;
36242   arg2 = (Dali::Vector2 *)jarg2;
36243   if (arg1) (arg1)->position = *arg2;
36244 }
36245
36246
36247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36248   void * jresult ;
36249   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36250   Dali::Vector2 *result = 0 ;
36251
36252   arg1 = (Dali::PanGesture *)jarg1;
36253   result = (Dali::Vector2 *)& ((arg1)->position);
36254   jresult = (void *)result;
36255   return jresult;
36256 }
36257
36258
36259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36260   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36261   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36262
36263   arg1 = (Dali::PanGesture *)jarg1;
36264   arg2 = (Dali::Vector2 *)jarg2;
36265   if (arg1) (arg1)->screenVelocity = *arg2;
36266 }
36267
36268
36269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36270   void * jresult ;
36271   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36272   Dali::Vector2 *result = 0 ;
36273
36274   arg1 = (Dali::PanGesture *)jarg1;
36275   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36276   jresult = (void *)result;
36277   return jresult;
36278 }
36279
36280
36281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36282   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36283   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36284
36285   arg1 = (Dali::PanGesture *)jarg1;
36286   arg2 = (Dali::Vector2 *)jarg2;
36287   if (arg1) (arg1)->screenDisplacement = *arg2;
36288 }
36289
36290
36291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36292   void * jresult ;
36293   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36294   Dali::Vector2 *result = 0 ;
36295
36296   arg1 = (Dali::PanGesture *)jarg1;
36297   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36298   jresult = (void *)result;
36299   return jresult;
36300 }
36301
36302
36303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36304   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36305   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36306
36307   arg1 = (Dali::PanGesture *)jarg1;
36308   arg2 = (Dali::Vector2 *)jarg2;
36309   if (arg1) (arg1)->screenPosition = *arg2;
36310 }
36311
36312
36313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36314   void * jresult ;
36315   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36316   Dali::Vector2 *result = 0 ;
36317
36318   arg1 = (Dali::PanGesture *)jarg1;
36319   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36320   jresult = (void *)result;
36321   return jresult;
36322 }
36323
36324
36325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36326   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36327   unsigned int arg2 ;
36328
36329   arg1 = (Dali::PanGesture *)jarg1;
36330   arg2 = (unsigned int)jarg2;
36331   if (arg1) (arg1)->numberOfTouches = arg2;
36332 }
36333
36334
36335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36336   unsigned int jresult ;
36337   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36338   unsigned int result;
36339
36340   arg1 = (Dali::PanGesture *)jarg1;
36341   result = (unsigned int) ((arg1)->numberOfTouches);
36342   jresult = result;
36343   return jresult;
36344 }
36345
36346
36347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36348   float jresult ;
36349   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36350   float result;
36351
36352   arg1 = (Dali::PanGesture *)jarg1;
36353   {
36354     try {
36355       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36356     } catch (std::out_of_range& e) {
36357       {
36358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (std::exception& e) {
36361       {
36362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36363       };
36364     } catch (...) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36367       };
36368     }
36369   }
36370   jresult = result;
36371   return jresult;
36372 }
36373
36374
36375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36376   float jresult ;
36377   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36378   float result;
36379
36380   arg1 = (Dali::PanGesture *)jarg1;
36381   {
36382     try {
36383       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (...) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36395       };
36396     }
36397   }
36398   jresult = result;
36399   return jresult;
36400 }
36401
36402
36403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36404   float jresult ;
36405   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36406   float result;
36407
36408   arg1 = (Dali::PanGesture *)jarg1;
36409   {
36410     try {
36411       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36412     } catch (std::out_of_range& e) {
36413       {
36414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36415       };
36416     } catch (std::exception& e) {
36417       {
36418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36419       };
36420     } catch (...) {
36421       {
36422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36423       };
36424     }
36425   }
36426   jresult = result;
36427   return jresult;
36428 }
36429
36430
36431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36432   float jresult ;
36433   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36434   float result;
36435
36436   arg1 = (Dali::PanGesture *)jarg1;
36437   {
36438     try {
36439       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36440     } catch (std::out_of_range& e) {
36441       {
36442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36443       };
36444     } catch (std::exception& e) {
36445       {
36446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (...) {
36449       {
36450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36451       };
36452     }
36453   }
36454   jresult = result;
36455   return jresult;
36456 }
36457
36458
36459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36460   void * jresult ;
36461   Dali::PinchGestureDetector *result = 0 ;
36462
36463   {
36464     try {
36465       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36466     } catch (std::out_of_range& e) {
36467       {
36468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (std::exception& e) {
36471       {
36472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36473       };
36474     } catch (...) {
36475       {
36476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36477       };
36478     }
36479   }
36480   jresult = (void *)result;
36481   return jresult;
36482 }
36483
36484
36485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36486   void * jresult ;
36487   Dali::PinchGestureDetector result;
36488
36489   {
36490     try {
36491       result = Dali::PinchGestureDetector::New();
36492     } catch (std::out_of_range& e) {
36493       {
36494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36495       };
36496     } catch (std::exception& e) {
36497       {
36498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36499       };
36500     } catch (...) {
36501       {
36502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36503       };
36504     }
36505   }
36506   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36507   return jresult;
36508 }
36509
36510
36511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36512   void * jresult ;
36513   Dali::BaseHandle arg1 ;
36514   Dali::BaseHandle *argp1 ;
36515   Dali::PinchGestureDetector result;
36516
36517   argp1 = (Dali::BaseHandle *)jarg1;
36518   if (!argp1) {
36519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36520     return 0;
36521   }
36522   arg1 = *argp1;
36523   {
36524     try {
36525       result = Dali::PinchGestureDetector::DownCast(arg1);
36526     } catch (std::out_of_range& e) {
36527       {
36528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36529       };
36530     } catch (std::exception& e) {
36531       {
36532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36533       };
36534     } catch (...) {
36535       {
36536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36537       };
36538     }
36539   }
36540   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36541   return jresult;
36542 }
36543
36544
36545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36546   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36547
36548   arg1 = (Dali::PinchGestureDetector *)jarg1;
36549   {
36550     try {
36551       delete arg1;
36552     } catch (std::out_of_range& e) {
36553       {
36554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36555       };
36556     } catch (std::exception& e) {
36557       {
36558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36559       };
36560     } catch (...) {
36561       {
36562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36563       };
36564     }
36565   }
36566 }
36567
36568
36569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36570   void * jresult ;
36571   Dali::PinchGestureDetector *arg1 = 0 ;
36572   Dali::PinchGestureDetector *result = 0 ;
36573
36574   arg1 = (Dali::PinchGestureDetector *)jarg1;
36575   if (!arg1) {
36576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36577     return 0;
36578   }
36579   {
36580     try {
36581       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36582     } catch (std::out_of_range& e) {
36583       {
36584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36585       };
36586     } catch (std::exception& e) {
36587       {
36588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36589       };
36590     } catch (...) {
36591       {
36592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36593       };
36594     }
36595   }
36596   jresult = (void *)result;
36597   return jresult;
36598 }
36599
36600
36601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36602   void * jresult ;
36603   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36604   Dali::PinchGestureDetector *arg2 = 0 ;
36605   Dali::PinchGestureDetector *result = 0 ;
36606
36607   arg1 = (Dali::PinchGestureDetector *)jarg1;
36608   arg2 = (Dali::PinchGestureDetector *)jarg2;
36609   if (!arg2) {
36610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36611     return 0;
36612   }
36613   {
36614     try {
36615       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36616     } catch (std::out_of_range& e) {
36617       {
36618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36619       };
36620     } catch (std::exception& e) {
36621       {
36622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36623       };
36624     } catch (...) {
36625       {
36626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36627       };
36628     }
36629   }
36630   jresult = (void *)result;
36631   return jresult;
36632 }
36633
36634
36635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36636   void * jresult ;
36637   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36638   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36639
36640   arg1 = (Dali::PinchGestureDetector *)jarg1;
36641   {
36642     try {
36643       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36644     } catch (std::out_of_range& e) {
36645       {
36646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36647       };
36648     } catch (std::exception& e) {
36649       {
36650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36651       };
36652     } catch (...) {
36653       {
36654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36655       };
36656     }
36657   }
36658   jresult = (void *)result;
36659   return jresult;
36660 }
36661
36662
36663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36664   void * jresult ;
36665   Dali::Gesture::State arg1 ;
36666   Dali::PinchGesture *result = 0 ;
36667
36668   arg1 = (Dali::Gesture::State)jarg1;
36669   {
36670     try {
36671       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36672     } catch (std::out_of_range& e) {
36673       {
36674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (std::exception& e) {
36677       {
36678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36683       };
36684     }
36685   }
36686   jresult = (void *)result;
36687   return jresult;
36688 }
36689
36690
36691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36692   void * jresult ;
36693   Dali::PinchGesture *arg1 = 0 ;
36694   Dali::PinchGesture *result = 0 ;
36695
36696   arg1 = (Dali::PinchGesture *)jarg1;
36697   if (!arg1) {
36698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36699     return 0;
36700   }
36701   {
36702     try {
36703       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36704     } catch (std::out_of_range& e) {
36705       {
36706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36707       };
36708     } catch (std::exception& e) {
36709       {
36710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36711       };
36712     } catch (...) {
36713       {
36714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36715       };
36716     }
36717   }
36718   jresult = (void *)result;
36719   return jresult;
36720 }
36721
36722
36723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36724   void * jresult ;
36725   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36726   Dali::PinchGesture *arg2 = 0 ;
36727   Dali::PinchGesture *result = 0 ;
36728
36729   arg1 = (Dali::PinchGesture *)jarg1;
36730   arg2 = (Dali::PinchGesture *)jarg2;
36731   if (!arg2) {
36732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36733     return 0;
36734   }
36735   {
36736     try {
36737       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36738     } catch (std::out_of_range& e) {
36739       {
36740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36741       };
36742     } catch (std::exception& e) {
36743       {
36744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36745       };
36746     } catch (...) {
36747       {
36748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36749       };
36750     }
36751   }
36752   jresult = (void *)result;
36753   return jresult;
36754 }
36755
36756
36757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36758   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36759
36760   arg1 = (Dali::PinchGesture *)jarg1;
36761   {
36762     try {
36763       delete arg1;
36764     } catch (std::out_of_range& e) {
36765       {
36766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36767       };
36768     } catch (std::exception& e) {
36769       {
36770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36771       };
36772     } catch (...) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36775       };
36776     }
36777   }
36778 }
36779
36780
36781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36782   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36783   float arg2 ;
36784
36785   arg1 = (Dali::PinchGesture *)jarg1;
36786   arg2 = (float)jarg2;
36787   if (arg1) (arg1)->scale = arg2;
36788 }
36789
36790
36791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36792   float jresult ;
36793   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36794   float result;
36795
36796   arg1 = (Dali::PinchGesture *)jarg1;
36797   result = (float) ((arg1)->scale);
36798   jresult = result;
36799   return jresult;
36800 }
36801
36802
36803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36804   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36805   float arg2 ;
36806
36807   arg1 = (Dali::PinchGesture *)jarg1;
36808   arg2 = (float)jarg2;
36809   if (arg1) (arg1)->speed = arg2;
36810 }
36811
36812
36813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36814   float jresult ;
36815   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36816   float result;
36817
36818   arg1 = (Dali::PinchGesture *)jarg1;
36819   result = (float) ((arg1)->speed);
36820   jresult = result;
36821   return jresult;
36822 }
36823
36824
36825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36826   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36827   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36828
36829   arg1 = (Dali::PinchGesture *)jarg1;
36830   arg2 = (Dali::Vector2 *)jarg2;
36831   if (arg1) (arg1)->screenCenterPoint = *arg2;
36832 }
36833
36834
36835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36836   void * jresult ;
36837   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36838   Dali::Vector2 *result = 0 ;
36839
36840   arg1 = (Dali::PinchGesture *)jarg1;
36841   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36842   jresult = (void *)result;
36843   return jresult;
36844 }
36845
36846
36847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36848   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36849   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36850
36851   arg1 = (Dali::PinchGesture *)jarg1;
36852   arg2 = (Dali::Vector2 *)jarg2;
36853   if (arg1) (arg1)->localCenterPoint = *arg2;
36854 }
36855
36856
36857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36858   void * jresult ;
36859   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36860   Dali::Vector2 *result = 0 ;
36861
36862   arg1 = (Dali::PinchGesture *)jarg1;
36863   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36864   jresult = (void *)result;
36865   return jresult;
36866 }
36867
36868
36869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36870   void * jresult ;
36871   Dali::TapGestureDetector *result = 0 ;
36872
36873   {
36874     try {
36875       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36876     } catch (std::out_of_range& e) {
36877       {
36878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (std::exception& e) {
36881       {
36882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36883       };
36884     } catch (...) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36887       };
36888     }
36889   }
36890   jresult = (void *)result;
36891   return jresult;
36892 }
36893
36894
36895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36896   void * jresult ;
36897   Dali::TapGestureDetector result;
36898
36899   {
36900     try {
36901       result = Dali::TapGestureDetector::New();
36902     } catch (std::out_of_range& e) {
36903       {
36904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36905       };
36906     } catch (std::exception& e) {
36907       {
36908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36909       };
36910     } catch (...) {
36911       {
36912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36913       };
36914     }
36915   }
36916   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36917   return jresult;
36918 }
36919
36920
36921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36922   void * jresult ;
36923   unsigned int arg1 ;
36924   Dali::TapGestureDetector result;
36925
36926   arg1 = (unsigned int)jarg1;
36927   {
36928     try {
36929       result = Dali::TapGestureDetector::New(arg1);
36930     } catch (std::out_of_range& e) {
36931       {
36932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36933       };
36934     } catch (std::exception& e) {
36935       {
36936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36937       };
36938     } catch (...) {
36939       {
36940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36941       };
36942     }
36943   }
36944   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36945   return jresult;
36946 }
36947
36948
36949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36950   void * jresult ;
36951   Dali::BaseHandle arg1 ;
36952   Dali::BaseHandle *argp1 ;
36953   Dali::TapGestureDetector result;
36954
36955   argp1 = (Dali::BaseHandle *)jarg1;
36956   if (!argp1) {
36957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36958     return 0;
36959   }
36960   arg1 = *argp1;
36961   {
36962     try {
36963       result = Dali::TapGestureDetector::DownCast(arg1);
36964     } catch (std::out_of_range& e) {
36965       {
36966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36967       };
36968     } catch (std::exception& e) {
36969       {
36970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36971       };
36972     } catch (...) {
36973       {
36974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36975       };
36976     }
36977   }
36978   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36979   return jresult;
36980 }
36981
36982
36983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36984   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36985
36986   arg1 = (Dali::TapGestureDetector *)jarg1;
36987   {
36988     try {
36989       delete arg1;
36990     } catch (std::out_of_range& e) {
36991       {
36992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36993       };
36994     } catch (std::exception& e) {
36995       {
36996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36997       };
36998     } catch (...) {
36999       {
37000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37001       };
37002     }
37003   }
37004 }
37005
37006
37007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
37008   void * jresult ;
37009   Dali::TapGestureDetector *arg1 = 0 ;
37010   Dali::TapGestureDetector *result = 0 ;
37011
37012   arg1 = (Dali::TapGestureDetector *)jarg1;
37013   if (!arg1) {
37014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37015     return 0;
37016   }
37017   {
37018     try {
37019       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
37020     } catch (std::out_of_range& e) {
37021       {
37022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37023       };
37024     } catch (std::exception& e) {
37025       {
37026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37027       };
37028     } catch (...) {
37029       {
37030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37031       };
37032     }
37033   }
37034   jresult = (void *)result;
37035   return jresult;
37036 }
37037
37038
37039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37040   void * jresult ;
37041   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37042   Dali::TapGestureDetector *arg2 = 0 ;
37043   Dali::TapGestureDetector *result = 0 ;
37044
37045   arg1 = (Dali::TapGestureDetector *)jarg1;
37046   arg2 = (Dali::TapGestureDetector *)jarg2;
37047   if (!arg2) {
37048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37049     return 0;
37050   }
37051   {
37052     try {
37053       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37054     } catch (std::out_of_range& e) {
37055       {
37056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37057       };
37058     } catch (std::exception& e) {
37059       {
37060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37061       };
37062     } catch (...) {
37063       {
37064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37065       };
37066     }
37067   }
37068   jresult = (void *)result;
37069   return jresult;
37070 }
37071
37072
37073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37074   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37075   unsigned int arg2 ;
37076
37077   arg1 = (Dali::TapGestureDetector *)jarg1;
37078   arg2 = (unsigned int)jarg2;
37079   {
37080     try {
37081       (arg1)->SetMinimumTapsRequired(arg2);
37082     } catch (std::out_of_range& e) {
37083       {
37084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37085       };
37086     } catch (std::exception& e) {
37087       {
37088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37089       };
37090     } catch (...) {
37091       {
37092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37093       };
37094     }
37095   }
37096 }
37097
37098
37099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37100   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37101   unsigned int arg2 ;
37102
37103   arg1 = (Dali::TapGestureDetector *)jarg1;
37104   arg2 = (unsigned int)jarg2;
37105   {
37106     try {
37107       (arg1)->SetMaximumTapsRequired(arg2);
37108     } catch (std::out_of_range& e) {
37109       {
37110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37111       };
37112     } catch (std::exception& e) {
37113       {
37114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37115       };
37116     } catch (...) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37119       };
37120     }
37121   }
37122 }
37123
37124
37125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37126   unsigned int jresult ;
37127   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37128   unsigned int result;
37129
37130   arg1 = (Dali::TapGestureDetector *)jarg1;
37131   {
37132     try {
37133       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (...) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37145       };
37146     }
37147   }
37148   jresult = result;
37149   return jresult;
37150 }
37151
37152
37153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37154   unsigned int jresult ;
37155   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37156   unsigned int result;
37157
37158   arg1 = (Dali::TapGestureDetector *)jarg1;
37159   {
37160     try {
37161       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37162     } catch (std::out_of_range& e) {
37163       {
37164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37165       };
37166     } catch (std::exception& e) {
37167       {
37168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (...) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37173       };
37174     }
37175   }
37176   jresult = result;
37177   return jresult;
37178 }
37179
37180
37181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37182   void * jresult ;
37183   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37184   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37185
37186   arg1 = (Dali::TapGestureDetector *)jarg1;
37187   {
37188     try {
37189       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37190     } catch (std::out_of_range& e) {
37191       {
37192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37193       };
37194     } catch (std::exception& e) {
37195       {
37196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37197       };
37198     } catch (...) {
37199       {
37200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37201       };
37202     }
37203   }
37204   jresult = (void *)result;
37205   return jresult;
37206 }
37207
37208
37209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37210   void * jresult ;
37211   Dali::TapGesture *result = 0 ;
37212
37213   {
37214     try {
37215       result = (Dali::TapGesture *)new Dali::TapGesture();
37216     } catch (std::out_of_range& e) {
37217       {
37218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37219       };
37220     } catch (std::exception& e) {
37221       {
37222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37223       };
37224     } catch (...) {
37225       {
37226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37227       };
37228     }
37229   }
37230   jresult = (void *)result;
37231   return jresult;
37232 }
37233
37234
37235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37236   void * jresult ;
37237   Dali::TapGesture *arg1 = 0 ;
37238   Dali::TapGesture *result = 0 ;
37239
37240   arg1 = (Dali::TapGesture *)jarg1;
37241   if (!arg1) {
37242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37243     return 0;
37244   }
37245   {
37246     try {
37247       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37248     } catch (std::out_of_range& e) {
37249       {
37250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37251       };
37252     } catch (std::exception& e) {
37253       {
37254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (...) {
37257       {
37258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37259       };
37260     }
37261   }
37262   jresult = (void *)result;
37263   return jresult;
37264 }
37265
37266
37267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37268   void * jresult ;
37269   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37270   Dali::TapGesture *arg2 = 0 ;
37271   Dali::TapGesture *result = 0 ;
37272
37273   arg1 = (Dali::TapGesture *)jarg1;
37274   arg2 = (Dali::TapGesture *)jarg2;
37275   if (!arg2) {
37276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37277     return 0;
37278   }
37279   {
37280     try {
37281       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37282     } catch (std::out_of_range& e) {
37283       {
37284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37285       };
37286     } catch (std::exception& e) {
37287       {
37288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37289       };
37290     } catch (...) {
37291       {
37292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37293       };
37294     }
37295   }
37296   jresult = (void *)result;
37297   return jresult;
37298 }
37299
37300
37301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37302   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37303
37304   arg1 = (Dali::TapGesture *)jarg1;
37305   {
37306     try {
37307       delete arg1;
37308     } catch (std::out_of_range& e) {
37309       {
37310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37311       };
37312     } catch (std::exception& e) {
37313       {
37314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37315       };
37316     } catch (...) {
37317       {
37318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37319       };
37320     }
37321   }
37322 }
37323
37324
37325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37326   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37327   unsigned int arg2 ;
37328
37329   arg1 = (Dali::TapGesture *)jarg1;
37330   arg2 = (unsigned int)jarg2;
37331   if (arg1) (arg1)->numberOfTaps = arg2;
37332 }
37333
37334
37335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37336   unsigned int jresult ;
37337   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37338   unsigned int result;
37339
37340   arg1 = (Dali::TapGesture *)jarg1;
37341   result = (unsigned int) ((arg1)->numberOfTaps);
37342   jresult = result;
37343   return jresult;
37344 }
37345
37346
37347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37348   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37349   unsigned int arg2 ;
37350
37351   arg1 = (Dali::TapGesture *)jarg1;
37352   arg2 = (unsigned int)jarg2;
37353   if (arg1) (arg1)->numberOfTouches = arg2;
37354 }
37355
37356
37357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37358   unsigned int jresult ;
37359   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37360   unsigned int result;
37361
37362   arg1 = (Dali::TapGesture *)jarg1;
37363   result = (unsigned int) ((arg1)->numberOfTouches);
37364   jresult = result;
37365   return jresult;
37366 }
37367
37368
37369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37370   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37371   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37372
37373   arg1 = (Dali::TapGesture *)jarg1;
37374   arg2 = (Dali::Vector2 *)jarg2;
37375   if (arg1) (arg1)->screenPoint = *arg2;
37376 }
37377
37378
37379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37380   void * jresult ;
37381   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37382   Dali::Vector2 *result = 0 ;
37383
37384   arg1 = (Dali::TapGesture *)jarg1;
37385   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37386   jresult = (void *)result;
37387   return jresult;
37388 }
37389
37390
37391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37392   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37393   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37394
37395   arg1 = (Dali::TapGesture *)jarg1;
37396   arg2 = (Dali::Vector2 *)jarg2;
37397   if (arg1) (arg1)->localPoint = *arg2;
37398 }
37399
37400
37401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37402   void * jresult ;
37403   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37404   Dali::Vector2 *result = 0 ;
37405
37406   arg1 = (Dali::TapGesture *)jarg1;
37407   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37408   jresult = (void *)result;
37409   return jresult;
37410 }
37411
37412
37413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37414   void * jresult ;
37415   Dali::AlphaFunction *result = 0 ;
37416
37417   {
37418     try {
37419       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37420     } catch (std::out_of_range& e) {
37421       {
37422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37423       };
37424     } catch (std::exception& e) {
37425       {
37426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37427       };
37428     } catch (...) {
37429       {
37430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37431       };
37432     }
37433   }
37434   jresult = (void *)result;
37435   return jresult;
37436 }
37437
37438
37439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37440   void * jresult ;
37441   Dali::AlphaFunction::BuiltinFunction arg1 ;
37442   Dali::AlphaFunction *result = 0 ;
37443
37444   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37445   {
37446     try {
37447       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37448     } catch (std::out_of_range& e) {
37449       {
37450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (std::exception& e) {
37453       {
37454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37455       };
37456     } catch (...) {
37457       {
37458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37459       };
37460     }
37461   }
37462   jresult = (void *)result;
37463   return jresult;
37464 }
37465
37466
37467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37468   void * jresult ;
37469   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37470   Dali::AlphaFunction *result = 0 ;
37471
37472   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37473   {
37474     try {
37475       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37476     } catch (std::out_of_range& e) {
37477       {
37478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37479       };
37480     } catch (std::exception& e) {
37481       {
37482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37483       };
37484     } catch (...) {
37485       {
37486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37487       };
37488     }
37489   }
37490   jresult = (void *)result;
37491   return jresult;
37492 }
37493
37494
37495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37496   void * jresult ;
37497   Dali::Vector2 *arg1 = 0 ;
37498   Dali::Vector2 *arg2 = 0 ;
37499   Dali::AlphaFunction *result = 0 ;
37500
37501   arg1 = (Dali::Vector2 *)jarg1;
37502   if (!arg1) {
37503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37504     return 0;
37505   }
37506   arg2 = (Dali::Vector2 *)jarg2;
37507   if (!arg2) {
37508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37509     return 0;
37510   }
37511   {
37512     try {
37513       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37514     } catch (std::out_of_range& e) {
37515       {
37516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37517       };
37518     } catch (std::exception& e) {
37519       {
37520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37521       };
37522     } catch (...) {
37523       {
37524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37525       };
37526     }
37527   }
37528   jresult = (void *)result;
37529   return jresult;
37530 }
37531
37532
37533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37534   void * jresult ;
37535   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37536   Dali::Vector4 result;
37537
37538   arg1 = (Dali::AlphaFunction *)jarg1;
37539   {
37540     try {
37541       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37542     } catch (std::out_of_range& e) {
37543       {
37544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37545       };
37546     } catch (std::exception& e) {
37547       {
37548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37549       };
37550     } catch (...) {
37551       {
37552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37553       };
37554     }
37555   }
37556   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37557   return jresult;
37558 }
37559
37560
37561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37562   void * jresult ;
37563   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37564   Dali::AlphaFunctionPrototype result;
37565
37566   arg1 = (Dali::AlphaFunction *)jarg1;
37567   {
37568     try {
37569       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37570     } catch (std::out_of_range& e) {
37571       {
37572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37573       };
37574     } catch (std::exception& e) {
37575       {
37576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37577       };
37578     } catch (...) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37581       };
37582     }
37583   }
37584   jresult = (void *)result;
37585   return jresult;
37586 }
37587
37588
37589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37590   int jresult ;
37591   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37592   Dali::AlphaFunction::BuiltinFunction result;
37593
37594   arg1 = (Dali::AlphaFunction *)jarg1;
37595   {
37596     try {
37597       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37598     } catch (std::out_of_range& e) {
37599       {
37600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37601       };
37602     } catch (std::exception& e) {
37603       {
37604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37605       };
37606     } catch (...) {
37607       {
37608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37609       };
37610     }
37611   }
37612   jresult = (int)result;
37613   return jresult;
37614 }
37615
37616
37617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37618   int jresult ;
37619   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37620   Dali::AlphaFunction::Mode result;
37621
37622   arg1 = (Dali::AlphaFunction *)jarg1;
37623   {
37624     try {
37625       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37626     } catch (std::out_of_range& e) {
37627       {
37628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37629       };
37630     } catch (std::exception& e) {
37631       {
37632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37633       };
37634     } catch (...) {
37635       {
37636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37637       };
37638     }
37639   }
37640   jresult = (int)result;
37641   return jresult;
37642 }
37643
37644
37645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37646   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37647
37648   arg1 = (Dali::AlphaFunction *)jarg1;
37649   {
37650     try {
37651       delete arg1;
37652     } catch (std::out_of_range& e) {
37653       {
37654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37655       };
37656     } catch (std::exception& e) {
37657       {
37658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37659       };
37660     } catch (...) {
37661       {
37662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37663       };
37664     }
37665   }
37666 }
37667
37668
37669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37670   void * jresult ;
37671   Dali::KeyFrames result;
37672
37673   {
37674     try {
37675       result = Dali::KeyFrames::New();
37676     } catch (std::out_of_range& e) {
37677       {
37678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37679       };
37680     } catch (std::exception& e) {
37681       {
37682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37683       };
37684     } catch (...) {
37685       {
37686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37687       };
37688     }
37689   }
37690   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37691   return jresult;
37692 }
37693
37694
37695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37696   void * jresult ;
37697   Dali::BaseHandle arg1 ;
37698   Dali::BaseHandle *argp1 ;
37699   Dali::KeyFrames result;
37700
37701   argp1 = (Dali::BaseHandle *)jarg1;
37702   if (!argp1) {
37703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37704     return 0;
37705   }
37706   arg1 = *argp1;
37707   {
37708     try {
37709       result = Dali::KeyFrames::DownCast(arg1);
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37721       };
37722     }
37723   }
37724   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37725   return jresult;
37726 }
37727
37728
37729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37730   void * jresult ;
37731   Dali::KeyFrames *result = 0 ;
37732
37733   {
37734     try {
37735       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37736     } catch (std::out_of_range& e) {
37737       {
37738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37739       };
37740     } catch (std::exception& e) {
37741       {
37742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37743       };
37744     } catch (...) {
37745       {
37746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37747       };
37748     }
37749   }
37750   jresult = (void *)result;
37751   return jresult;
37752 }
37753
37754
37755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37756   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37757
37758   arg1 = (Dali::KeyFrames *)jarg1;
37759   {
37760     try {
37761       delete arg1;
37762     } catch (std::out_of_range& e) {
37763       {
37764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (std::exception& e) {
37767       {
37768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (...) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37773       };
37774     }
37775   }
37776 }
37777
37778
37779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37780   void * jresult ;
37781   Dali::KeyFrames *arg1 = 0 ;
37782   Dali::KeyFrames *result = 0 ;
37783
37784   arg1 = (Dali::KeyFrames *)jarg1;
37785   if (!arg1) {
37786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37787     return 0;
37788   }
37789   {
37790     try {
37791       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37792     } catch (std::out_of_range& e) {
37793       {
37794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37795       };
37796     } catch (std::exception& e) {
37797       {
37798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37799       };
37800     } catch (...) {
37801       {
37802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37803       };
37804     }
37805   }
37806   jresult = (void *)result;
37807   return jresult;
37808 }
37809
37810
37811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37812   void * jresult ;
37813   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37814   Dali::KeyFrames *arg2 = 0 ;
37815   Dali::KeyFrames *result = 0 ;
37816
37817   arg1 = (Dali::KeyFrames *)jarg1;
37818   arg2 = (Dali::KeyFrames *)jarg2;
37819   if (!arg2) {
37820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37821     return 0;
37822   }
37823   {
37824     try {
37825       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37826     } catch (std::out_of_range& e) {
37827       {
37828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37829       };
37830     } catch (std::exception& e) {
37831       {
37832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37833       };
37834     } catch (...) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37837       };
37838     }
37839   }
37840   jresult = (void *)result;
37841   return jresult;
37842 }
37843
37844
37845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37846   int jresult ;
37847   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37848   Dali::Property::Type result;
37849
37850   arg1 = (Dali::KeyFrames *)jarg1;
37851   {
37852     try {
37853       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37854     } catch (std::out_of_range& e) {
37855       {
37856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37857       };
37858     } catch (std::exception& e) {
37859       {
37860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37861       };
37862     } catch (...) {
37863       {
37864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37865       };
37866     }
37867   }
37868   jresult = (int)result;
37869   return jresult;
37870 }
37871
37872
37873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37874   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37875   float arg2 ;
37876   Dali::Property::Value arg3 ;
37877   Dali::Property::Value *argp3 ;
37878
37879   arg1 = (Dali::KeyFrames *)jarg1;
37880   arg2 = (float)jarg2;
37881   argp3 = (Dali::Property::Value *)jarg3;
37882   if (!argp3) {
37883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37884     return ;
37885   }
37886   arg3 = *argp3;
37887   {
37888     try {
37889       (arg1)->Add(arg2,arg3);
37890     } catch (std::out_of_range& e) {
37891       {
37892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37893       };
37894     } catch (std::exception& e) {
37895       {
37896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37897       };
37898     } catch (...) {
37899       {
37900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37901       };
37902     }
37903   }
37904 }
37905
37906
37907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37908   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37909   float arg2 ;
37910   Dali::Property::Value arg3 ;
37911   Dali::AlphaFunction arg4 ;
37912   Dali::Property::Value *argp3 ;
37913   Dali::AlphaFunction *argp4 ;
37914
37915   arg1 = (Dali::KeyFrames *)jarg1;
37916   arg2 = (float)jarg2;
37917   argp3 = (Dali::Property::Value *)jarg3;
37918   if (!argp3) {
37919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37920     return ;
37921   }
37922   arg3 = *argp3;
37923   argp4 = (Dali::AlphaFunction *)jarg4;
37924   if (!argp4) {
37925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37926     return ;
37927   }
37928   arg4 = *argp4;
37929   {
37930     try {
37931       (arg1)->Add(arg2,arg3,arg4);
37932     } catch (std::out_of_range& e) {
37933       {
37934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37935       };
37936     } catch (std::exception& e) {
37937       {
37938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37939       };
37940     } catch (...) {
37941       {
37942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37943       };
37944     }
37945   }
37946 }
37947
37948
37949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37950   int jresult ;
37951   int result;
37952
37953   result = (int)Dali::Path::Property::POINTS;
37954   jresult = (int)result;
37955   return jresult;
37956 }
37957
37958
37959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37960   int jresult ;
37961   int result;
37962
37963   result = (int)Dali::Path::Property::CONTROL_POINTS;
37964   jresult = (int)result;
37965   return jresult;
37966 }
37967
37968
37969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37970   void * jresult ;
37971   Dali::Path::Property *result = 0 ;
37972
37973   {
37974     try {
37975       result = (Dali::Path::Property *)new Dali::Path::Property();
37976     } catch (std::out_of_range& e) {
37977       {
37978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (std::exception& e) {
37981       {
37982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37983       };
37984     } catch (...) {
37985       {
37986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37987       };
37988     }
37989   }
37990   jresult = (void *)result;
37991   return jresult;
37992 }
37993
37994
37995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37996   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37997
37998   arg1 = (Dali::Path::Property *)jarg1;
37999   {
38000     try {
38001       delete arg1;
38002     } catch (std::out_of_range& e) {
38003       {
38004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38005       };
38006     } catch (std::exception& e) {
38007       {
38008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38009       };
38010     } catch (...) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38013       };
38014     }
38015   }
38016 }
38017
38018
38019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
38020   void * jresult ;
38021   Dali::Path result;
38022
38023   {
38024     try {
38025       result = Dali::Path::New();
38026     } catch (std::out_of_range& e) {
38027       {
38028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38029       };
38030     } catch (std::exception& e) {
38031       {
38032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38033       };
38034     } catch (...) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38037       };
38038     }
38039   }
38040   jresult = new Dali::Path((const Dali::Path &)result);
38041   return jresult;
38042 }
38043
38044
38045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38046   void * jresult ;
38047   Dali::BaseHandle arg1 ;
38048   Dali::BaseHandle *argp1 ;
38049   Dali::Path result;
38050
38051   argp1 = (Dali::BaseHandle *)jarg1;
38052   if (!argp1) {
38053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38054     return 0;
38055   }
38056   arg1 = *argp1;
38057   {
38058     try {
38059       result = Dali::Path::DownCast(arg1);
38060     } catch (std::out_of_range& e) {
38061       {
38062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38063       };
38064     } catch (std::exception& e) {
38065       {
38066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38067       };
38068     } catch (...) {
38069       {
38070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38071       };
38072     }
38073   }
38074   jresult = new Dali::Path((const Dali::Path &)result);
38075   return jresult;
38076 }
38077
38078
38079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38080   void * jresult ;
38081   Dali::Path *result = 0 ;
38082
38083   {
38084     try {
38085       result = (Dali::Path *)new Dali::Path();
38086     } catch (std::out_of_range& e) {
38087       {
38088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38089       };
38090     } catch (std::exception& e) {
38091       {
38092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38093       };
38094     } catch (...) {
38095       {
38096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38097       };
38098     }
38099   }
38100   jresult = (void *)result;
38101   return jresult;
38102 }
38103
38104
38105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38106   Dali::Path *arg1 = (Dali::Path *) 0 ;
38107
38108   arg1 = (Dali::Path *)jarg1;
38109   {
38110     try {
38111       delete arg1;
38112     } catch (std::out_of_range& e) {
38113       {
38114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38115       };
38116     } catch (std::exception& e) {
38117       {
38118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38119       };
38120     } catch (...) {
38121       {
38122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38123       };
38124     }
38125   }
38126 }
38127
38128
38129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38130   void * jresult ;
38131   Dali::Path *arg1 = 0 ;
38132   Dali::Path *result = 0 ;
38133
38134   arg1 = (Dali::Path *)jarg1;
38135   if (!arg1) {
38136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38137     return 0;
38138   }
38139   {
38140     try {
38141       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38142     } catch (std::out_of_range& e) {
38143       {
38144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38145       };
38146     } catch (std::exception& e) {
38147       {
38148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38149       };
38150     } catch (...) {
38151       {
38152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38153       };
38154     }
38155   }
38156   jresult = (void *)result;
38157   return jresult;
38158 }
38159
38160
38161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38162   void * jresult ;
38163   Dali::Path *arg1 = (Dali::Path *) 0 ;
38164   Dali::Path *arg2 = 0 ;
38165   Dali::Path *result = 0 ;
38166
38167   arg1 = (Dali::Path *)jarg1;
38168   arg2 = (Dali::Path *)jarg2;
38169   if (!arg2) {
38170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38171     return 0;
38172   }
38173   {
38174     try {
38175       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38176     } catch (std::out_of_range& e) {
38177       {
38178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38179       };
38180     } catch (std::exception& e) {
38181       {
38182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38183       };
38184     } catch (...) {
38185       {
38186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38187       };
38188     }
38189   }
38190   jresult = (void *)result;
38191   return jresult;
38192 }
38193
38194
38195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38196   Dali::Path *arg1 = (Dali::Path *) 0 ;
38197   Dali::Vector3 *arg2 = 0 ;
38198
38199   arg1 = (Dali::Path *)jarg1;
38200   arg2 = (Dali::Vector3 *)jarg2;
38201   if (!arg2) {
38202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38203     return ;
38204   }
38205   {
38206     try {
38207       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38208     } catch (std::out_of_range& e) {
38209       {
38210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38211       };
38212     } catch (std::exception& e) {
38213       {
38214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38215       };
38216     } catch (...) {
38217       {
38218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38219       };
38220     }
38221   }
38222 }
38223
38224
38225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38226   Dali::Path *arg1 = (Dali::Path *) 0 ;
38227   Dali::Vector3 *arg2 = 0 ;
38228
38229   arg1 = (Dali::Path *)jarg1;
38230   arg2 = (Dali::Vector3 *)jarg2;
38231   if (!arg2) {
38232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38233     return ;
38234   }
38235   {
38236     try {
38237       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38238     } catch (std::out_of_range& e) {
38239       {
38240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38241       };
38242     } catch (std::exception& e) {
38243       {
38244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38245       };
38246     } catch (...) {
38247       {
38248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38249       };
38250     }
38251   }
38252 }
38253
38254
38255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38256   Dali::Path *arg1 = (Dali::Path *) 0 ;
38257   float arg2 ;
38258
38259   arg1 = (Dali::Path *)jarg1;
38260   arg2 = (float)jarg2;
38261   {
38262     try {
38263       (arg1)->GenerateControlPoints(arg2);
38264     } catch (std::out_of_range& e) {
38265       {
38266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38267       };
38268     } catch (std::exception& e) {
38269       {
38270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38271       };
38272     } catch (...) {
38273       {
38274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38275       };
38276     }
38277   }
38278 }
38279
38280
38281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38282   Dali::Path *arg1 = (Dali::Path *) 0 ;
38283   float arg2 ;
38284   Dali::Vector3 *arg3 = 0 ;
38285   Dali::Vector3 *arg4 = 0 ;
38286
38287   arg1 = (Dali::Path *)jarg1;
38288   arg2 = (float)jarg2;
38289   arg3 = (Dali::Vector3 *)jarg3;
38290   if (!arg3) {
38291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38292     return ;
38293   }
38294   arg4 = (Dali::Vector3 *)jarg4;
38295   if (!arg4) {
38296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38297     return ;
38298   }
38299   {
38300     try {
38301       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38302     } catch (std::out_of_range& e) {
38303       {
38304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38305       };
38306     } catch (std::exception& e) {
38307       {
38308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38309       };
38310     } catch (...) {
38311       {
38312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38313       };
38314     }
38315   }
38316 }
38317
38318
38319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38320   void * jresult ;
38321   Dali::Path *arg1 = (Dali::Path *) 0 ;
38322   size_t arg2 ;
38323   Dali::Vector3 *result = 0 ;
38324
38325   arg1 = (Dali::Path *)jarg1;
38326   arg2 = (size_t)jarg2;
38327   {
38328     try {
38329       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (...) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38341       };
38342     }
38343   }
38344   jresult = (void *)result;
38345   return jresult;
38346 }
38347
38348
38349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38350   void * jresult ;
38351   Dali::Path *arg1 = (Dali::Path *) 0 ;
38352   size_t arg2 ;
38353   Dali::Vector3 *result = 0 ;
38354
38355   arg1 = (Dali::Path *)jarg1;
38356   arg2 = (size_t)jarg2;
38357   {
38358     try {
38359       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38360     } catch (std::out_of_range& e) {
38361       {
38362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38363       };
38364     } catch (std::exception& e) {
38365       {
38366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38367       };
38368     } catch (...) {
38369       {
38370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38371       };
38372     }
38373   }
38374   jresult = (void *)result;
38375   return jresult;
38376 }
38377
38378
38379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38380   unsigned long jresult ;
38381   Dali::Path *arg1 = (Dali::Path *) 0 ;
38382   size_t result;
38383
38384   arg1 = (Dali::Path *)jarg1;
38385   {
38386     try {
38387       result = ((Dali::Path const *)arg1)->GetPointCount();
38388     } catch (std::out_of_range& e) {
38389       {
38390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38391       };
38392     } catch (std::exception& e) {
38393       {
38394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38395       };
38396     } catch (...) {
38397       {
38398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38399       };
38400     }
38401   }
38402   jresult = (unsigned long)result;
38403   return jresult;
38404 }
38405
38406
38407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38408   void * jresult ;
38409   float arg1 ;
38410   Dali::TimePeriod *result = 0 ;
38411
38412   arg1 = (float)jarg1;
38413   {
38414     try {
38415       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38416     } catch (std::out_of_range& e) {
38417       {
38418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38419       };
38420     } catch (std::exception& e) {
38421       {
38422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38423       };
38424     } catch (...) {
38425       {
38426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38427       };
38428     }
38429   }
38430   jresult = (void *)result;
38431   return jresult;
38432 }
38433
38434
38435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38436   void * jresult ;
38437   float arg1 ;
38438   float arg2 ;
38439   Dali::TimePeriod *result = 0 ;
38440
38441   arg1 = (float)jarg1;
38442   arg2 = (float)jarg2;
38443   {
38444     try {
38445       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38446     } catch (std::out_of_range& e) {
38447       {
38448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38449       };
38450     } catch (std::exception& e) {
38451       {
38452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38453       };
38454     } catch (...) {
38455       {
38456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38457       };
38458     }
38459   }
38460   jresult = (void *)result;
38461   return jresult;
38462 }
38463
38464
38465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38466   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38467
38468   arg1 = (Dali::TimePeriod *)jarg1;
38469   {
38470     try {
38471       delete arg1;
38472     } catch (std::out_of_range& e) {
38473       {
38474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38475       };
38476     } catch (std::exception& e) {
38477       {
38478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38479       };
38480     } catch (...) {
38481       {
38482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38483       };
38484     }
38485   }
38486 }
38487
38488
38489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38490   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38491   float arg2 ;
38492
38493   arg1 = (Dali::TimePeriod *)jarg1;
38494   arg2 = (float)jarg2;
38495   if (arg1) (arg1)->delaySeconds = arg2;
38496 }
38497
38498
38499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38500   float jresult ;
38501   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38502   float result;
38503
38504   arg1 = (Dali::TimePeriod *)jarg1;
38505   result = (float) ((arg1)->delaySeconds);
38506   jresult = result;
38507   return jresult;
38508 }
38509
38510
38511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38512   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38513   float arg2 ;
38514
38515   arg1 = (Dali::TimePeriod *)jarg1;
38516   arg2 = (float)jarg2;
38517   if (arg1) (arg1)->durationSeconds = arg2;
38518 }
38519
38520
38521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38522   float jresult ;
38523   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38524   float result;
38525
38526   arg1 = (Dali::TimePeriod *)jarg1;
38527   result = (float) ((arg1)->durationSeconds);
38528   jresult = result;
38529   return jresult;
38530 }
38531
38532
38533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38534   void * jresult ;
38535   Dali::Animation *result = 0 ;
38536
38537   {
38538     try {
38539       result = (Dali::Animation *)new Dali::Animation();
38540     } catch (std::out_of_range& e) {
38541       {
38542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38543       };
38544     } catch (std::exception& e) {
38545       {
38546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38547       };
38548     } catch (...) {
38549       {
38550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38551       };
38552     }
38553   }
38554   jresult = (void *)result;
38555   return jresult;
38556 }
38557
38558
38559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38560   void * jresult ;
38561   float arg1 ;
38562   Dali::Animation result;
38563
38564   arg1 = (float)jarg1;
38565   {
38566     try {
38567       result = Dali::Animation::New(arg1);
38568     } catch (std::out_of_range& e) {
38569       {
38570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38571       };
38572     } catch (std::exception& e) {
38573       {
38574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38579       };
38580     }
38581   }
38582   jresult = new Dali::Animation((const Dali::Animation &)result);
38583   return jresult;
38584 }
38585
38586
38587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38588   void * jresult ;
38589   Dali::BaseHandle arg1 ;
38590   Dali::BaseHandle *argp1 ;
38591   Dali::Animation result;
38592
38593   argp1 = (Dali::BaseHandle *)jarg1;
38594   if (!argp1) {
38595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38596     return 0;
38597   }
38598   arg1 = *argp1;
38599   {
38600     try {
38601       result = Dali::Animation::DownCast(arg1);
38602     } catch (std::out_of_range& e) {
38603       {
38604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (std::exception& e) {
38607       {
38608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (...) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38613       };
38614     }
38615   }
38616   jresult = new Dali::Animation((const Dali::Animation &)result);
38617   return jresult;
38618 }
38619
38620
38621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38622   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38623
38624   arg1 = (Dali::Animation *)jarg1;
38625   {
38626     try {
38627       delete arg1;
38628     } catch (std::out_of_range& e) {
38629       {
38630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38631       };
38632     } catch (std::exception& e) {
38633       {
38634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38635       };
38636     } catch (...) {
38637       {
38638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38639       };
38640     }
38641   }
38642 }
38643
38644
38645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38646   void * jresult ;
38647   Dali::Animation *arg1 = 0 ;
38648   Dali::Animation *result = 0 ;
38649
38650   arg1 = (Dali::Animation *)jarg1;
38651   if (!arg1) {
38652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38653     return 0;
38654   }
38655   {
38656     try {
38657       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38658     } catch (std::out_of_range& e) {
38659       {
38660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38661       };
38662     } catch (std::exception& e) {
38663       {
38664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38665       };
38666     } catch (...) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38669       };
38670     }
38671   }
38672   jresult = (void *)result;
38673   return jresult;
38674 }
38675
38676
38677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38678   void * jresult ;
38679   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38680   Dali::Animation *arg2 = 0 ;
38681   Dali::Animation *result = 0 ;
38682
38683   arg1 = (Dali::Animation *)jarg1;
38684   arg2 = (Dali::Animation *)jarg2;
38685   if (!arg2) {
38686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38687     return 0;
38688   }
38689   {
38690     try {
38691       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38692     } catch (std::out_of_range& e) {
38693       {
38694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38695       };
38696     } catch (std::exception& e) {
38697       {
38698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38699       };
38700     } catch (...) {
38701       {
38702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38703       };
38704     }
38705   }
38706   jresult = (void *)result;
38707   return jresult;
38708 }
38709
38710
38711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38712   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38713   float arg2 ;
38714
38715   arg1 = (Dali::Animation *)jarg1;
38716   arg2 = (float)jarg2;
38717   {
38718     try {
38719       (arg1)->SetDuration(arg2);
38720     } catch (std::out_of_range& e) {
38721       {
38722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38723       };
38724     } catch (std::exception& e) {
38725       {
38726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38727       };
38728     } catch (...) {
38729       {
38730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38731       };
38732     }
38733   }
38734 }
38735
38736
38737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38738   float jresult ;
38739   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38740   float result;
38741
38742   arg1 = (Dali::Animation *)jarg1;
38743   {
38744     try {
38745       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38746     } catch (std::out_of_range& e) {
38747       {
38748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38749       };
38750     } catch (std::exception& e) {
38751       {
38752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38757       };
38758     }
38759   }
38760   jresult = result;
38761   return jresult;
38762 }
38763
38764
38765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38766   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38767   bool arg2 ;
38768
38769   arg1 = (Dali::Animation *)jarg1;
38770   arg2 = jarg2 ? true : false;
38771   {
38772     try {
38773       (arg1)->SetLooping(arg2);
38774     } catch (std::out_of_range& e) {
38775       {
38776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38777       };
38778     } catch (std::exception& e) {
38779       {
38780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38781       };
38782     } catch (...) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38785       };
38786     }
38787   }
38788 }
38789
38790
38791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38792   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38793   int arg2 ;
38794
38795   arg1 = (Dali::Animation *)jarg1;
38796   arg2 = (int)jarg2;
38797   {
38798     try {
38799       (arg1)->SetLoopCount(arg2);
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38807       };
38808     } catch (...) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38811       };
38812     }
38813   }
38814 }
38815
38816
38817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38818   int jresult ;
38819   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38820   int result;
38821
38822   arg1 = (Dali::Animation *)jarg1;
38823   {
38824     try {
38825       result = (int)(arg1)->GetLoopCount();
38826     } catch (std::out_of_range& e) {
38827       {
38828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38829       };
38830     } catch (std::exception& e) {
38831       {
38832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38833       };
38834     } catch (...) {
38835       {
38836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38837       };
38838     }
38839   }
38840   jresult = result;
38841   return jresult;
38842 }
38843
38844
38845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38846   int jresult ;
38847   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38848   int result;
38849
38850   arg1 = (Dali::Animation *)jarg1;
38851   {
38852     try {
38853       result = (int)(arg1)->GetCurrentLoop();
38854     } catch (std::out_of_range& e) {
38855       {
38856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38857       };
38858     } catch (std::exception& e) {
38859       {
38860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (...) {
38863       {
38864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38865       };
38866     }
38867   }
38868   jresult = result;
38869   return jresult;
38870 }
38871
38872
38873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38874   unsigned int jresult ;
38875   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38876   bool result;
38877
38878   arg1 = (Dali::Animation *)jarg1;
38879   {
38880     try {
38881       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38882     } catch (std::out_of_range& e) {
38883       {
38884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38885       };
38886     } catch (std::exception& e) {
38887       {
38888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38893       };
38894     }
38895   }
38896   jresult = result;
38897   return jresult;
38898 }
38899
38900
38901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38902   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38903   Dali::Animation::EndAction arg2 ;
38904
38905   arg1 = (Dali::Animation *)jarg1;
38906   arg2 = (Dali::Animation::EndAction)jarg2;
38907   {
38908     try {
38909       (arg1)->SetEndAction(arg2);
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38921       };
38922     }
38923   }
38924 }
38925
38926
38927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38928   int jresult ;
38929   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38930   Dali::Animation::EndAction result;
38931
38932   arg1 = (Dali::Animation *)jarg1;
38933   {
38934     try {
38935       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38936     } catch (std::out_of_range& e) {
38937       {
38938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38939       };
38940     } catch (std::exception& e) {
38941       {
38942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38943       };
38944     } catch (...) {
38945       {
38946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38947       };
38948     }
38949   }
38950   jresult = (int)result;
38951   return jresult;
38952 }
38953
38954
38955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38956   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38957   Dali::Animation::EndAction arg2 ;
38958
38959   arg1 = (Dali::Animation *)jarg1;
38960   arg2 = (Dali::Animation::EndAction)jarg2;
38961   {
38962     try {
38963       (arg1)->SetDisconnectAction(arg2);
38964     } catch (std::out_of_range& e) {
38965       {
38966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38967       };
38968     } catch (std::exception& e) {
38969       {
38970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38971       };
38972     } catch (...) {
38973       {
38974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38975       };
38976     }
38977   }
38978 }
38979
38980
38981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38982   int jresult ;
38983   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38984   Dali::Animation::EndAction result;
38985
38986   arg1 = (Dali::Animation *)jarg1;
38987   {
38988     try {
38989       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38990     } catch (std::out_of_range& e) {
38991       {
38992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38993       };
38994     } catch (std::exception& e) {
38995       {
38996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38997       };
38998     } catch (...) {
38999       {
39000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39001       };
39002     }
39003   }
39004   jresult = (int)result;
39005   return jresult;
39006 }
39007
39008
39009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
39010   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39011   Dali::AlphaFunction arg2 ;
39012   Dali::AlphaFunction *argp2 ;
39013
39014   arg1 = (Dali::Animation *)jarg1;
39015   argp2 = (Dali::AlphaFunction *)jarg2;
39016   if (!argp2) {
39017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39018     return ;
39019   }
39020   arg2 = *argp2;
39021   {
39022     try {
39023       (arg1)->SetDefaultAlphaFunction(arg2);
39024     } catch (std::out_of_range& e) {
39025       {
39026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39027       };
39028     } catch (std::exception& e) {
39029       {
39030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39031       };
39032     } catch (...) {
39033       {
39034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39035       };
39036     }
39037   }
39038 }
39039
39040
39041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39042   void * jresult ;
39043   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39044   Dali::AlphaFunction result;
39045
39046   arg1 = (Dali::Animation *)jarg1;
39047   {
39048     try {
39049       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39057       };
39058     } catch (...) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39061       };
39062     }
39063   }
39064   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39065   return jresult;
39066 }
39067
39068
39069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39070   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39071   float arg2 ;
39072
39073   arg1 = (Dali::Animation *)jarg1;
39074   arg2 = (float)jarg2;
39075   {
39076     try {
39077       (arg1)->SetCurrentProgress(arg2);
39078     } catch (std::out_of_range& e) {
39079       {
39080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39081       };
39082     } catch (std::exception& e) {
39083       {
39084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39085       };
39086     } catch (...) {
39087       {
39088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39089       };
39090     }
39091   }
39092 }
39093
39094
39095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39096   float jresult ;
39097   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39098   float result;
39099
39100   arg1 = (Dali::Animation *)jarg1;
39101   {
39102     try {
39103       result = (float)(arg1)->GetCurrentProgress();
39104     } catch (std::out_of_range& e) {
39105       {
39106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39107       };
39108     } catch (std::exception& e) {
39109       {
39110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39111       };
39112     } catch (...) {
39113       {
39114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39115       };
39116     }
39117   }
39118   jresult = result;
39119   return jresult;
39120 }
39121
39122
39123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39124   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39125   float arg2 ;
39126
39127   arg1 = (Dali::Animation *)jarg1;
39128   arg2 = (float)jarg2;
39129   {
39130     try {
39131       (arg1)->SetSpeedFactor(arg2);
39132     } catch (std::out_of_range& e) {
39133       {
39134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39135       };
39136     } catch (std::exception& e) {
39137       {
39138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39139       };
39140     } catch (...) {
39141       {
39142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39143       };
39144     }
39145   }
39146 }
39147
39148
39149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39150   float jresult ;
39151   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39152   float result;
39153
39154   arg1 = (Dali::Animation *)jarg1;
39155   {
39156     try {
39157       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39158     } catch (std::out_of_range& e) {
39159       {
39160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39161       };
39162     } catch (std::exception& e) {
39163       {
39164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39165       };
39166     } catch (...) {
39167       {
39168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39169       };
39170     }
39171   }
39172   jresult = result;
39173   return jresult;
39174 }
39175
39176
39177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39178   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39179   Dali::Vector2 *arg2 = 0 ;
39180
39181   arg1 = (Dali::Animation *)jarg1;
39182   arg2 = (Dali::Vector2 *)jarg2;
39183   if (!arg2) {
39184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39185     return ;
39186   }
39187   {
39188     try {
39189       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39190     } catch (std::out_of_range& e) {
39191       {
39192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (std::exception& e) {
39195       {
39196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39197       };
39198     } catch (...) {
39199       {
39200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39201       };
39202     }
39203   }
39204 }
39205
39206
39207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39208   void * jresult ;
39209   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39210   Dali::Vector2 result;
39211
39212   arg1 = (Dali::Animation *)jarg1;
39213   {
39214     try {
39215       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39216     } catch (std::out_of_range& e) {
39217       {
39218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39219       };
39220     } catch (std::exception& e) {
39221       {
39222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39223       };
39224     } catch (...) {
39225       {
39226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39227       };
39228     }
39229   }
39230   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39236   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39237
39238   arg1 = (Dali::Animation *)jarg1;
39239   {
39240     try {
39241       (arg1)->Play();
39242     } catch (std::out_of_range& e) {
39243       {
39244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39245       };
39246     } catch (std::exception& e) {
39247       {
39248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39249       };
39250     } catch (...) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39253       };
39254     }
39255   }
39256 }
39257
39258
39259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39260   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39261   float arg2 ;
39262
39263   arg1 = (Dali::Animation *)jarg1;
39264   arg2 = (float)jarg2;
39265   {
39266     try {
39267       (arg1)->PlayFrom(arg2);
39268     } catch (std::out_of_range& e) {
39269       {
39270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39271       };
39272     } catch (std::exception& e) {
39273       {
39274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39275       };
39276     } catch (...) {
39277       {
39278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39279       };
39280     }
39281   }
39282 }
39283
39284
39285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39286   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39287
39288   arg1 = (Dali::Animation *)jarg1;
39289   {
39290     try {
39291       (arg1)->Pause();
39292     } catch (std::out_of_range& e) {
39293       {
39294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39295       };
39296     } catch (std::exception& e) {
39297       {
39298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39299       };
39300     } catch (...) {
39301       {
39302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39303       };
39304     }
39305   }
39306 }
39307
39308
39309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39310   int jresult ;
39311   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39312   Dali::Animation::State result;
39313
39314   arg1 = (Dali::Animation *)jarg1;
39315   {
39316     try {
39317       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39318     } catch (std::out_of_range& e) {
39319       {
39320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (std::exception& e) {
39323       {
39324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39325       };
39326     } catch (...) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39329       };
39330     }
39331   }
39332   jresult = (int)result;
39333   return jresult;
39334 }
39335
39336
39337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39338   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39339
39340   arg1 = (Dali::Animation *)jarg1;
39341   {
39342     try {
39343       (arg1)->Stop();
39344     } catch (std::out_of_range& e) {
39345       {
39346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39347       };
39348     } catch (std::exception& e) {
39349       {
39350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39351       };
39352     } catch (...) {
39353       {
39354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39355       };
39356     }
39357   }
39358 }
39359
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39362   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39363
39364   arg1 = (Dali::Animation *)jarg1;
39365   {
39366     try {
39367       (arg1)->Clear();
39368     } catch (std::out_of_range& e) {
39369       {
39370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39371       };
39372     } catch (std::exception& e) {
39373       {
39374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39375       };
39376     } catch (...) {
39377       {
39378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39379       };
39380     }
39381   }
39382 }
39383
39384
39385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39386   void * jresult ;
39387   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39388   Dali::Animation::AnimationSignalType *result = 0 ;
39389
39390   arg1 = (Dali::Animation *)jarg1;
39391   {
39392     try {
39393       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39394     } catch (std::out_of_range& e) {
39395       {
39396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39397       };
39398     } catch (std::exception& e) {
39399       {
39400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39401       };
39402     } catch (...) {
39403       {
39404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39405       };
39406     }
39407   }
39408   jresult = (void *)result;
39409   return jresult;
39410 }
39411
39412
39413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39414   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39415   SwigValueWrapper< Dali::Property > arg2 ;
39416   Dali::Property::Value arg3 ;
39417   Dali::Property *argp2 ;
39418   Dali::Property::Value *argp3 ;
39419
39420   arg1 = (Dali::Animation *)jarg1;
39421   argp2 = (Dali::Property *)jarg2;
39422   if (!argp2) {
39423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39424     return ;
39425   }
39426   arg2 = *argp2;
39427   argp3 = (Dali::Property::Value *)jarg3;
39428   if (!argp3) {
39429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39430     return ;
39431   }
39432   arg3 = *argp3;
39433   {
39434     try {
39435       (arg1)->AnimateBy(arg2,arg3);
39436     } catch (std::out_of_range& e) {
39437       {
39438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (std::exception& e) {
39441       {
39442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39443       };
39444     } catch (...) {
39445       {
39446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39447       };
39448     }
39449   }
39450 }
39451
39452
39453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39454   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39455   SwigValueWrapper< Dali::Property > arg2 ;
39456   Dali::Property::Value arg3 ;
39457   Dali::AlphaFunction arg4 ;
39458   Dali::Property *argp2 ;
39459   Dali::Property::Value *argp3 ;
39460   Dali::AlphaFunction *argp4 ;
39461
39462   arg1 = (Dali::Animation *)jarg1;
39463   argp2 = (Dali::Property *)jarg2;
39464   if (!argp2) {
39465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39466     return ;
39467   }
39468   arg2 = *argp2;
39469   argp3 = (Dali::Property::Value *)jarg3;
39470   if (!argp3) {
39471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39472     return ;
39473   }
39474   arg3 = *argp3;
39475   argp4 = (Dali::AlphaFunction *)jarg4;
39476   if (!argp4) {
39477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39478     return ;
39479   }
39480   arg4 = *argp4;
39481   {
39482     try {
39483       (arg1)->AnimateBy(arg2,arg3,arg4);
39484     } catch (std::out_of_range& e) {
39485       {
39486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39487       };
39488     } catch (std::exception& e) {
39489       {
39490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39491       };
39492     } catch (...) {
39493       {
39494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39495       };
39496     }
39497   }
39498 }
39499
39500
39501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39502   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39503   SwigValueWrapper< Dali::Property > arg2 ;
39504   Dali::Property::Value arg3 ;
39505   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39506   Dali::Property *argp2 ;
39507   Dali::Property::Value *argp3 ;
39508   Dali::TimePeriod *argp4 ;
39509
39510   arg1 = (Dali::Animation *)jarg1;
39511   argp2 = (Dali::Property *)jarg2;
39512   if (!argp2) {
39513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39514     return ;
39515   }
39516   arg2 = *argp2;
39517   argp3 = (Dali::Property::Value *)jarg3;
39518   if (!argp3) {
39519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39520     return ;
39521   }
39522   arg3 = *argp3;
39523   argp4 = (Dali::TimePeriod *)jarg4;
39524   if (!argp4) {
39525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39526     return ;
39527   }
39528   arg4 = *argp4;
39529   {
39530     try {
39531       (arg1)->AnimateBy(arg2,arg3,arg4);
39532     } catch (std::out_of_range& e) {
39533       {
39534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39535       };
39536     } catch (std::exception& e) {
39537       {
39538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39539       };
39540     } catch (...) {
39541       {
39542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39543       };
39544     }
39545   }
39546 }
39547
39548
39549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39550   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39551   SwigValueWrapper< Dali::Property > arg2 ;
39552   Dali::Property::Value arg3 ;
39553   Dali::AlphaFunction arg4 ;
39554   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39555   Dali::Property *argp2 ;
39556   Dali::Property::Value *argp3 ;
39557   Dali::AlphaFunction *argp4 ;
39558   Dali::TimePeriod *argp5 ;
39559
39560   arg1 = (Dali::Animation *)jarg1;
39561   argp2 = (Dali::Property *)jarg2;
39562   if (!argp2) {
39563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39564     return ;
39565   }
39566   arg2 = *argp2;
39567   argp3 = (Dali::Property::Value *)jarg3;
39568   if (!argp3) {
39569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39570     return ;
39571   }
39572   arg3 = *argp3;
39573   argp4 = (Dali::AlphaFunction *)jarg4;
39574   if (!argp4) {
39575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39576     return ;
39577   }
39578   arg4 = *argp4;
39579   argp5 = (Dali::TimePeriod *)jarg5;
39580   if (!argp5) {
39581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39582     return ;
39583   }
39584   arg5 = *argp5;
39585   {
39586     try {
39587       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39588     } catch (std::out_of_range& e) {
39589       {
39590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39591       };
39592     } catch (std::exception& e) {
39593       {
39594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39595       };
39596     } catch (...) {
39597       {
39598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39599       };
39600     }
39601   }
39602 }
39603
39604
39605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39606   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39607   SwigValueWrapper< Dali::Property > arg2 ;
39608   Dali::Property::Value arg3 ;
39609   Dali::Property *argp2 ;
39610   Dali::Property::Value *argp3 ;
39611
39612   arg1 = (Dali::Animation *)jarg1;
39613   argp2 = (Dali::Property *)jarg2;
39614   if (!argp2) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39616     return ;
39617   }
39618   arg2 = *argp2;
39619   argp3 = (Dali::Property::Value *)jarg3;
39620   if (!argp3) {
39621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39622     return ;
39623   }
39624   arg3 = *argp3;
39625   {
39626     try {
39627       (arg1)->AnimateTo(arg2,arg3);
39628     } catch (std::out_of_range& e) {
39629       {
39630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39631       };
39632     } catch (std::exception& e) {
39633       {
39634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39635       };
39636     } catch (...) {
39637       {
39638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39639       };
39640     }
39641   }
39642 }
39643
39644
39645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39646   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39647   SwigValueWrapper< Dali::Property > arg2 ;
39648   Dali::Property::Value arg3 ;
39649   Dali::AlphaFunction arg4 ;
39650   Dali::Property *argp2 ;
39651   Dali::Property::Value *argp3 ;
39652   Dali::AlphaFunction *argp4 ;
39653
39654   arg1 = (Dali::Animation *)jarg1;
39655   argp2 = (Dali::Property *)jarg2;
39656   if (!argp2) {
39657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39658     return ;
39659   }
39660   arg2 = *argp2;
39661   argp3 = (Dali::Property::Value *)jarg3;
39662   if (!argp3) {
39663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39664     return ;
39665   }
39666   arg3 = *argp3;
39667   argp4 = (Dali::AlphaFunction *)jarg4;
39668   if (!argp4) {
39669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39670     return ;
39671   }
39672   arg4 = *argp4;
39673   {
39674     try {
39675       (arg1)->AnimateTo(arg2,arg3,arg4);
39676     } catch (std::out_of_range& e) {
39677       {
39678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39679       };
39680     } catch (std::exception& e) {
39681       {
39682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39683       };
39684     } catch (...) {
39685       {
39686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39687       };
39688     }
39689   }
39690 }
39691
39692
39693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39694   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39695   SwigValueWrapper< Dali::Property > arg2 ;
39696   Dali::Property::Value arg3 ;
39697   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39698   Dali::Property *argp2 ;
39699   Dali::Property::Value *argp3 ;
39700   Dali::TimePeriod *argp4 ;
39701
39702   arg1 = (Dali::Animation *)jarg1;
39703   argp2 = (Dali::Property *)jarg2;
39704   if (!argp2) {
39705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39706     return ;
39707   }
39708   arg2 = *argp2;
39709   argp3 = (Dali::Property::Value *)jarg3;
39710   if (!argp3) {
39711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39712     return ;
39713   }
39714   arg3 = *argp3;
39715   argp4 = (Dali::TimePeriod *)jarg4;
39716   if (!argp4) {
39717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39718     return ;
39719   }
39720   arg4 = *argp4;
39721   {
39722     try {
39723       (arg1)->AnimateTo(arg2,arg3,arg4);
39724     } catch (std::out_of_range& e) {
39725       {
39726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39727       };
39728     } catch (std::exception& e) {
39729       {
39730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39731       };
39732     } catch (...) {
39733       {
39734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39735       };
39736     }
39737   }
39738 }
39739
39740
39741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39742   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39743   SwigValueWrapper< Dali::Property > arg2 ;
39744   Dali::Property::Value arg3 ;
39745   Dali::AlphaFunction arg4 ;
39746   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39747   Dali::Property *argp2 ;
39748   Dali::Property::Value *argp3 ;
39749   Dali::AlphaFunction *argp4 ;
39750   Dali::TimePeriod *argp5 ;
39751
39752   arg1 = (Dali::Animation *)jarg1;
39753   argp2 = (Dali::Property *)jarg2;
39754   if (!argp2) {
39755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39756     return ;
39757   }
39758   arg2 = *argp2;
39759   argp3 = (Dali::Property::Value *)jarg3;
39760   if (!argp3) {
39761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39762     return ;
39763   }
39764   arg3 = *argp3;
39765   argp4 = (Dali::AlphaFunction *)jarg4;
39766   if (!argp4) {
39767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39768     return ;
39769   }
39770   arg4 = *argp4;
39771   argp5 = (Dali::TimePeriod *)jarg5;
39772   if (!argp5) {
39773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39774     return ;
39775   }
39776   arg5 = *argp5;
39777   {
39778     try {
39779       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39780     } catch (std::out_of_range& e) {
39781       {
39782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39783       };
39784     } catch (std::exception& e) {
39785       {
39786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39787       };
39788     } catch (...) {
39789       {
39790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39791       };
39792     }
39793   }
39794 }
39795
39796
39797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39798   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39799   SwigValueWrapper< Dali::Property > arg2 ;
39800   Dali::KeyFrames *arg3 = 0 ;
39801   Dali::Property *argp2 ;
39802
39803   arg1 = (Dali::Animation *)jarg1;
39804   argp2 = (Dali::Property *)jarg2;
39805   if (!argp2) {
39806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39807     return ;
39808   }
39809   arg2 = *argp2;
39810   arg3 = (Dali::KeyFrames *)jarg3;
39811   if (!arg3) {
39812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39813     return ;
39814   }
39815   {
39816     try {
39817       (arg1)->AnimateBetween(arg2,*arg3);
39818     } catch (std::out_of_range& e) {
39819       {
39820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39821       };
39822     } catch (std::exception& e) {
39823       {
39824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39825       };
39826     } catch (...) {
39827       {
39828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39829       };
39830     }
39831   }
39832 }
39833
39834
39835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39836   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39837   SwigValueWrapper< Dali::Property > arg2 ;
39838   Dali::KeyFrames *arg3 = 0 ;
39839   Dali::Animation::Interpolation arg4 ;
39840   Dali::Property *argp2 ;
39841
39842   arg1 = (Dali::Animation *)jarg1;
39843   argp2 = (Dali::Property *)jarg2;
39844   if (!argp2) {
39845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39846     return ;
39847   }
39848   arg2 = *argp2;
39849   arg3 = (Dali::KeyFrames *)jarg3;
39850   if (!arg3) {
39851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39852     return ;
39853   }
39854   arg4 = (Dali::Animation::Interpolation)jarg4;
39855   {
39856     try {
39857       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39858     } catch (std::out_of_range& e) {
39859       {
39860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39861       };
39862     } catch (std::exception& e) {
39863       {
39864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39865       };
39866     } catch (...) {
39867       {
39868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39869       };
39870     }
39871   }
39872 }
39873
39874
39875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39876   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39877   SwigValueWrapper< Dali::Property > arg2 ;
39878   Dali::KeyFrames *arg3 = 0 ;
39879   Dali::AlphaFunction arg4 ;
39880   Dali::Property *argp2 ;
39881   Dali::AlphaFunction *argp4 ;
39882
39883   arg1 = (Dali::Animation *)jarg1;
39884   argp2 = (Dali::Property *)jarg2;
39885   if (!argp2) {
39886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39887     return ;
39888   }
39889   arg2 = *argp2;
39890   arg3 = (Dali::KeyFrames *)jarg3;
39891   if (!arg3) {
39892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39893     return ;
39894   }
39895   argp4 = (Dali::AlphaFunction *)jarg4;
39896   if (!argp4) {
39897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39898     return ;
39899   }
39900   arg4 = *argp4;
39901   {
39902     try {
39903       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39904     } catch (std::out_of_range& e) {
39905       {
39906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39907       };
39908     } catch (std::exception& e) {
39909       {
39910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39911       };
39912     } catch (...) {
39913       {
39914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39915       };
39916     }
39917   }
39918 }
39919
39920
39921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39922   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39923   SwigValueWrapper< Dali::Property > arg2 ;
39924   Dali::KeyFrames *arg3 = 0 ;
39925   Dali::AlphaFunction arg4 ;
39926   Dali::Animation::Interpolation arg5 ;
39927   Dali::Property *argp2 ;
39928   Dali::AlphaFunction *argp4 ;
39929
39930   arg1 = (Dali::Animation *)jarg1;
39931   argp2 = (Dali::Property *)jarg2;
39932   if (!argp2) {
39933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39934     return ;
39935   }
39936   arg2 = *argp2;
39937   arg3 = (Dali::KeyFrames *)jarg3;
39938   if (!arg3) {
39939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39940     return ;
39941   }
39942   argp4 = (Dali::AlphaFunction *)jarg4;
39943   if (!argp4) {
39944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39945     return ;
39946   }
39947   arg4 = *argp4;
39948   arg5 = (Dali::Animation::Interpolation)jarg5;
39949   {
39950     try {
39951       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39959       };
39960     } catch (...) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39963       };
39964     }
39965   }
39966 }
39967
39968
39969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39970   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39971   SwigValueWrapper< Dali::Property > arg2 ;
39972   Dali::KeyFrames *arg3 = 0 ;
39973   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39974   Dali::Property *argp2 ;
39975   Dali::TimePeriod *argp4 ;
39976
39977   arg1 = (Dali::Animation *)jarg1;
39978   argp2 = (Dali::Property *)jarg2;
39979   if (!argp2) {
39980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39981     return ;
39982   }
39983   arg2 = *argp2;
39984   arg3 = (Dali::KeyFrames *)jarg3;
39985   if (!arg3) {
39986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39987     return ;
39988   }
39989   argp4 = (Dali::TimePeriod *)jarg4;
39990   if (!argp4) {
39991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39992     return ;
39993   }
39994   arg4 = *argp4;
39995   {
39996     try {
39997       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39998     } catch (std::out_of_range& e) {
39999       {
40000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40001       };
40002     } catch (std::exception& e) {
40003       {
40004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40009       };
40010     }
40011   }
40012 }
40013
40014
40015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40016   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40017   SwigValueWrapper< Dali::Property > arg2 ;
40018   Dali::KeyFrames *arg3 = 0 ;
40019   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40020   Dali::Animation::Interpolation arg5 ;
40021   Dali::Property *argp2 ;
40022   Dali::TimePeriod *argp4 ;
40023
40024   arg1 = (Dali::Animation *)jarg1;
40025   argp2 = (Dali::Property *)jarg2;
40026   if (!argp2) {
40027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40028     return ;
40029   }
40030   arg2 = *argp2;
40031   arg3 = (Dali::KeyFrames *)jarg3;
40032   if (!arg3) {
40033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40034     return ;
40035   }
40036   argp4 = (Dali::TimePeriod *)jarg4;
40037   if (!argp4) {
40038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40039     return ;
40040   }
40041   arg4 = *argp4;
40042   arg5 = (Dali::Animation::Interpolation)jarg5;
40043   {
40044     try {
40045       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40046     } catch (std::out_of_range& e) {
40047       {
40048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40049       };
40050     } catch (std::exception& e) {
40051       {
40052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40053       };
40054     } catch (...) {
40055       {
40056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40057       };
40058     }
40059   }
40060 }
40061
40062
40063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40064   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40065   SwigValueWrapper< Dali::Property > arg2 ;
40066   Dali::KeyFrames *arg3 = 0 ;
40067   Dali::AlphaFunction arg4 ;
40068   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40069   Dali::Property *argp2 ;
40070   Dali::AlphaFunction *argp4 ;
40071   Dali::TimePeriod *argp5 ;
40072
40073   arg1 = (Dali::Animation *)jarg1;
40074   argp2 = (Dali::Property *)jarg2;
40075   if (!argp2) {
40076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40077     return ;
40078   }
40079   arg2 = *argp2;
40080   arg3 = (Dali::KeyFrames *)jarg3;
40081   if (!arg3) {
40082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40083     return ;
40084   }
40085   argp4 = (Dali::AlphaFunction *)jarg4;
40086   if (!argp4) {
40087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40088     return ;
40089   }
40090   arg4 = *argp4;
40091   argp5 = (Dali::TimePeriod *)jarg5;
40092   if (!argp5) {
40093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40094     return ;
40095   }
40096   arg5 = *argp5;
40097   {
40098     try {
40099       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40100     } catch (std::out_of_range& e) {
40101       {
40102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40103       };
40104     } catch (std::exception& e) {
40105       {
40106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40107       };
40108     } catch (...) {
40109       {
40110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40111       };
40112     }
40113   }
40114 }
40115
40116
40117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40118   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40119   SwigValueWrapper< Dali::Property > arg2 ;
40120   Dali::KeyFrames *arg3 = 0 ;
40121   Dali::AlphaFunction arg4 ;
40122   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40123   Dali::Animation::Interpolation arg6 ;
40124   Dali::Property *argp2 ;
40125   Dali::AlphaFunction *argp4 ;
40126   Dali::TimePeriod *argp5 ;
40127
40128   arg1 = (Dali::Animation *)jarg1;
40129   argp2 = (Dali::Property *)jarg2;
40130   if (!argp2) {
40131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40132     return ;
40133   }
40134   arg2 = *argp2;
40135   arg3 = (Dali::KeyFrames *)jarg3;
40136   if (!arg3) {
40137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40138     return ;
40139   }
40140   argp4 = (Dali::AlphaFunction *)jarg4;
40141   if (!argp4) {
40142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40143     return ;
40144   }
40145   arg4 = *argp4;
40146   argp5 = (Dali::TimePeriod *)jarg5;
40147   if (!argp5) {
40148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40149     return ;
40150   }
40151   arg5 = *argp5;
40152   arg6 = (Dali::Animation::Interpolation)jarg6;
40153   {
40154     try {
40155       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40156     } catch (std::out_of_range& e) {
40157       {
40158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40159       };
40160     } catch (std::exception& e) {
40161       {
40162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40163       };
40164     } catch (...) {
40165       {
40166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40167       };
40168     }
40169   }
40170 }
40171
40172
40173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40174   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40175   Dali::Actor arg2 ;
40176   Dali::Path arg3 ;
40177   Dali::Vector3 *arg4 = 0 ;
40178   Dali::Actor *argp2 ;
40179   Dali::Path *argp3 ;
40180
40181   arg1 = (Dali::Animation *)jarg1;
40182   argp2 = (Dali::Actor *)jarg2;
40183   if (!argp2) {
40184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40185     return ;
40186   }
40187   arg2 = *argp2;
40188   argp3 = (Dali::Path *)jarg3;
40189   if (!argp3) {
40190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40191     return ;
40192   }
40193   arg3 = *argp3;
40194   arg4 = (Dali::Vector3 *)jarg4;
40195   if (!arg4) {
40196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40197     return ;
40198   }
40199   {
40200     try {
40201       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40202     } catch (std::out_of_range& e) {
40203       {
40204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40205       };
40206     } catch (std::exception& e) {
40207       {
40208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40209       };
40210     } catch (...) {
40211       {
40212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40213       };
40214     }
40215   }
40216 }
40217
40218
40219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40220   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40221   Dali::Actor arg2 ;
40222   Dali::Path arg3 ;
40223   Dali::Vector3 *arg4 = 0 ;
40224   Dali::AlphaFunction arg5 ;
40225   Dali::Actor *argp2 ;
40226   Dali::Path *argp3 ;
40227   Dali::AlphaFunction *argp5 ;
40228
40229   arg1 = (Dali::Animation *)jarg1;
40230   argp2 = (Dali::Actor *)jarg2;
40231   if (!argp2) {
40232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40233     return ;
40234   }
40235   arg2 = *argp2;
40236   argp3 = (Dali::Path *)jarg3;
40237   if (!argp3) {
40238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40239     return ;
40240   }
40241   arg3 = *argp3;
40242   arg4 = (Dali::Vector3 *)jarg4;
40243   if (!arg4) {
40244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40245     return ;
40246   }
40247   argp5 = (Dali::AlphaFunction *)jarg5;
40248   if (!argp5) {
40249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40250     return ;
40251   }
40252   arg5 = *argp5;
40253   {
40254     try {
40255       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40256     } catch (std::out_of_range& e) {
40257       {
40258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40259       };
40260     } catch (std::exception& e) {
40261       {
40262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40263       };
40264     } catch (...) {
40265       {
40266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40267       };
40268     }
40269   }
40270 }
40271
40272
40273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40274   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40275   Dali::Actor arg2 ;
40276   Dali::Path arg3 ;
40277   Dali::Vector3 *arg4 = 0 ;
40278   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40279   Dali::Actor *argp2 ;
40280   Dali::Path *argp3 ;
40281   Dali::TimePeriod *argp5 ;
40282
40283   arg1 = (Dali::Animation *)jarg1;
40284   argp2 = (Dali::Actor *)jarg2;
40285   if (!argp2) {
40286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40287     return ;
40288   }
40289   arg2 = *argp2;
40290   argp3 = (Dali::Path *)jarg3;
40291   if (!argp3) {
40292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40293     return ;
40294   }
40295   arg3 = *argp3;
40296   arg4 = (Dali::Vector3 *)jarg4;
40297   if (!arg4) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40299     return ;
40300   }
40301   argp5 = (Dali::TimePeriod *)jarg5;
40302   if (!argp5) {
40303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40304     return ;
40305   }
40306   arg5 = *argp5;
40307   {
40308     try {
40309       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40310     } catch (std::out_of_range& e) {
40311       {
40312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (std::exception& e) {
40315       {
40316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40317       };
40318     } catch (...) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40321       };
40322     }
40323   }
40324 }
40325
40326
40327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40328   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40329   Dali::Actor arg2 ;
40330   Dali::Path arg3 ;
40331   Dali::Vector3 *arg4 = 0 ;
40332   Dali::AlphaFunction arg5 ;
40333   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40334   Dali::Actor *argp2 ;
40335   Dali::Path *argp3 ;
40336   Dali::AlphaFunction *argp5 ;
40337   Dali::TimePeriod *argp6 ;
40338
40339   arg1 = (Dali::Animation *)jarg1;
40340   argp2 = (Dali::Actor *)jarg2;
40341   if (!argp2) {
40342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40343     return ;
40344   }
40345   arg2 = *argp2;
40346   argp3 = (Dali::Path *)jarg3;
40347   if (!argp3) {
40348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40349     return ;
40350   }
40351   arg3 = *argp3;
40352   arg4 = (Dali::Vector3 *)jarg4;
40353   if (!arg4) {
40354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40355     return ;
40356   }
40357   argp5 = (Dali::AlphaFunction *)jarg5;
40358   if (!argp5) {
40359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40360     return ;
40361   }
40362   arg5 = *argp5;
40363   argp6 = (Dali::TimePeriod *)jarg6;
40364   if (!argp6) {
40365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40366     return ;
40367   }
40368   arg6 = *argp6;
40369   {
40370     try {
40371       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40372     } catch (std::out_of_range& e) {
40373       {
40374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40375       };
40376     } catch (std::exception& e) {
40377       {
40378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40379       };
40380     } catch (...) {
40381       {
40382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40383       };
40384     }
40385   }
40386 }
40387
40388
40389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40390   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40391   Dali::Actor arg2 ;
40392   float arg3 ;
40393   Dali::Actor *argp2 ;
40394
40395   arg1 = (Dali::Animation *)jarg1;
40396   argp2 = (Dali::Actor *)jarg2;
40397   if (!argp2) {
40398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40399     return ;
40400   }
40401   arg2 = *argp2;
40402   arg3 = (float)jarg3;
40403   {
40404     try {
40405       (arg1)->Show(arg2,arg3);
40406     } catch (std::out_of_range& e) {
40407       {
40408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40409       };
40410     } catch (std::exception& e) {
40411       {
40412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40413       };
40414     } catch (...) {
40415       {
40416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40417       };
40418     }
40419   }
40420 }
40421
40422
40423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40424   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40425   Dali::Actor arg2 ;
40426   float arg3 ;
40427   Dali::Actor *argp2 ;
40428
40429   arg1 = (Dali::Animation *)jarg1;
40430   argp2 = (Dali::Actor *)jarg2;
40431   if (!argp2) {
40432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40433     return ;
40434   }
40435   arg2 = *argp2;
40436   arg3 = (float)jarg3;
40437   {
40438     try {
40439       (arg1)->Hide(arg2,arg3);
40440     } catch (std::out_of_range& e) {
40441       {
40442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40443       };
40444     } catch (std::exception& e) {
40445       {
40446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40447       };
40448     } catch (...) {
40449       {
40450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40451       };
40452     }
40453   }
40454 }
40455
40456
40457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40458   int jresult ;
40459   int result;
40460
40461   result = (int)Dali::LinearConstrainer::Property::VALUE;
40462   jresult = (int)result;
40463   return jresult;
40464 }
40465
40466
40467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40468   int jresult ;
40469   int result;
40470
40471   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40472   jresult = (int)result;
40473   return jresult;
40474 }
40475
40476
40477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40478   void * jresult ;
40479   Dali::LinearConstrainer::Property *result = 0 ;
40480
40481   {
40482     try {
40483       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40484     } catch (std::out_of_range& e) {
40485       {
40486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40487       };
40488     } catch (std::exception& e) {
40489       {
40490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40491       };
40492     } catch (...) {
40493       {
40494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40495       };
40496     }
40497   }
40498   jresult = (void *)result;
40499   return jresult;
40500 }
40501
40502
40503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40504   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40505
40506   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40507   {
40508     try {
40509       delete arg1;
40510     } catch (std::out_of_range& e) {
40511       {
40512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40513       };
40514     } catch (std::exception& e) {
40515       {
40516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40521       };
40522     }
40523   }
40524 }
40525
40526
40527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40528   void * jresult ;
40529   Dali::LinearConstrainer result;
40530
40531   {
40532     try {
40533       result = Dali::LinearConstrainer::New();
40534     } catch (std::out_of_range& e) {
40535       {
40536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (std::exception& e) {
40539       {
40540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40541       };
40542     } catch (...) {
40543       {
40544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40545       };
40546     }
40547   }
40548   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40549   return jresult;
40550 }
40551
40552
40553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40554   void * jresult ;
40555   Dali::BaseHandle arg1 ;
40556   Dali::BaseHandle *argp1 ;
40557   Dali::LinearConstrainer result;
40558
40559   argp1 = (Dali::BaseHandle *)jarg1;
40560   if (!argp1) {
40561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40562     return 0;
40563   }
40564   arg1 = *argp1;
40565   {
40566     try {
40567       result = Dali::LinearConstrainer::DownCast(arg1);
40568     } catch (std::out_of_range& e) {
40569       {
40570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40571       };
40572     } catch (std::exception& e) {
40573       {
40574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40575       };
40576     } catch (...) {
40577       {
40578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40579       };
40580     }
40581   }
40582   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40588   void * jresult ;
40589   Dali::LinearConstrainer *result = 0 ;
40590
40591   {
40592     try {
40593       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40594     } catch (std::out_of_range& e) {
40595       {
40596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40597       };
40598     } catch (std::exception& e) {
40599       {
40600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (...) {
40603       {
40604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40605       };
40606     }
40607   }
40608   jresult = (void *)result;
40609   return jresult;
40610 }
40611
40612
40613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40614   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40615
40616   arg1 = (Dali::LinearConstrainer *)jarg1;
40617   {
40618     try {
40619       delete arg1;
40620     } catch (std::out_of_range& e) {
40621       {
40622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40623       };
40624     } catch (std::exception& e) {
40625       {
40626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40627       };
40628     } catch (...) {
40629       {
40630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40631       };
40632     }
40633   }
40634 }
40635
40636
40637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40638   void * jresult ;
40639   Dali::LinearConstrainer *arg1 = 0 ;
40640   Dali::LinearConstrainer *result = 0 ;
40641
40642   arg1 = (Dali::LinearConstrainer *)jarg1;
40643   if (!arg1) {
40644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40645     return 0;
40646   }
40647   {
40648     try {
40649       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40650     } catch (std::out_of_range& e) {
40651       {
40652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40653       };
40654     } catch (std::exception& e) {
40655       {
40656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40657       };
40658     } catch (...) {
40659       {
40660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40661       };
40662     }
40663   }
40664   jresult = (void *)result;
40665   return jresult;
40666 }
40667
40668
40669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40670   void * jresult ;
40671   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40672   Dali::LinearConstrainer *arg2 = 0 ;
40673   Dali::LinearConstrainer *result = 0 ;
40674
40675   arg1 = (Dali::LinearConstrainer *)jarg1;
40676   arg2 = (Dali::LinearConstrainer *)jarg2;
40677   if (!arg2) {
40678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40679     return 0;
40680   }
40681   {
40682     try {
40683       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40684     } catch (std::out_of_range& e) {
40685       {
40686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40687       };
40688     } catch (std::exception& e) {
40689       {
40690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40691       };
40692     } catch (...) {
40693       {
40694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40695       };
40696     }
40697   }
40698   jresult = (void *)result;
40699   return jresult;
40700 }
40701
40702
40703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40704   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40705   SwigValueWrapper< Dali::Property > arg2 ;
40706   SwigValueWrapper< Dali::Property > arg3 ;
40707   Dali::Vector2 *arg4 = 0 ;
40708   Dali::Vector2 *arg5 = 0 ;
40709   Dali::Property *argp2 ;
40710   Dali::Property *argp3 ;
40711
40712   arg1 = (Dali::LinearConstrainer *)jarg1;
40713   argp2 = (Dali::Property *)jarg2;
40714   if (!argp2) {
40715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40716     return ;
40717   }
40718   arg2 = *argp2;
40719   argp3 = (Dali::Property *)jarg3;
40720   if (!argp3) {
40721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40722     return ;
40723   }
40724   arg3 = *argp3;
40725   arg4 = (Dali::Vector2 *)jarg4;
40726   if (!arg4) {
40727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40728     return ;
40729   }
40730   arg5 = (Dali::Vector2 *)jarg5;
40731   if (!arg5) {
40732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40733     return ;
40734   }
40735   {
40736     try {
40737       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40738     } catch (std::out_of_range& e) {
40739       {
40740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40741       };
40742     } catch (std::exception& e) {
40743       {
40744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40745       };
40746     } catch (...) {
40747       {
40748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40749       };
40750     }
40751   }
40752 }
40753
40754
40755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40756   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40757   SwigValueWrapper< Dali::Property > arg2 ;
40758   SwigValueWrapper< Dali::Property > arg3 ;
40759   Dali::Vector2 *arg4 = 0 ;
40760   Dali::Property *argp2 ;
40761   Dali::Property *argp3 ;
40762
40763   arg1 = (Dali::LinearConstrainer *)jarg1;
40764   argp2 = (Dali::Property *)jarg2;
40765   if (!argp2) {
40766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40767     return ;
40768   }
40769   arg2 = *argp2;
40770   argp3 = (Dali::Property *)jarg3;
40771   if (!argp3) {
40772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40773     return ;
40774   }
40775   arg3 = *argp3;
40776   arg4 = (Dali::Vector2 *)jarg4;
40777   if (!arg4) {
40778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40779     return ;
40780   }
40781   {
40782     try {
40783       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40784     } catch (std::out_of_range& e) {
40785       {
40786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40787       };
40788     } catch (std::exception& e) {
40789       {
40790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40791       };
40792     } catch (...) {
40793       {
40794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40795       };
40796     }
40797   }
40798 }
40799
40800
40801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40802   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40803   Dali::Handle *arg2 = 0 ;
40804
40805   arg1 = (Dali::LinearConstrainer *)jarg1;
40806   arg2 = (Dali::Handle *)jarg2;
40807   if (!arg2) {
40808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40809     return ;
40810   }
40811   {
40812     try {
40813       (arg1)->Remove(*arg2);
40814     } catch (std::out_of_range& e) {
40815       {
40816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (std::exception& e) {
40819       {
40820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40821       };
40822     } catch (...) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40825       };
40826     }
40827   }
40828 }
40829
40830
40831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40832   int jresult ;
40833   int result;
40834
40835   result = (int)Dali::PathConstrainer::Property::FORWARD;
40836   jresult = (int)result;
40837   return jresult;
40838 }
40839
40840
40841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40842   int jresult ;
40843   int result;
40844
40845   result = (int)Dali::PathConstrainer::Property::POINTS;
40846   jresult = (int)result;
40847   return jresult;
40848 }
40849
40850
40851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40852   int jresult ;
40853   int result;
40854
40855   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40856   jresult = (int)result;
40857   return jresult;
40858 }
40859
40860
40861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40862   void * jresult ;
40863   Dali::PathConstrainer::Property *result = 0 ;
40864
40865   {
40866     try {
40867       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40868     } catch (std::out_of_range& e) {
40869       {
40870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40871       };
40872     } catch (std::exception& e) {
40873       {
40874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40875       };
40876     } catch (...) {
40877       {
40878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40879       };
40880     }
40881   }
40882   jresult = (void *)result;
40883   return jresult;
40884 }
40885
40886
40887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40888   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40889
40890   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40891   {
40892     try {
40893       delete arg1;
40894     } catch (std::out_of_range& e) {
40895       {
40896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40897       };
40898     } catch (std::exception& e) {
40899       {
40900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40901       };
40902     } catch (...) {
40903       {
40904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40905       };
40906     }
40907   }
40908 }
40909
40910
40911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40912   void * jresult ;
40913   Dali::PathConstrainer result;
40914
40915   {
40916     try {
40917       result = Dali::PathConstrainer::New();
40918     } catch (std::out_of_range& e) {
40919       {
40920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40921       };
40922     } catch (std::exception& e) {
40923       {
40924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40925       };
40926     } catch (...) {
40927       {
40928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40929       };
40930     }
40931   }
40932   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40933   return jresult;
40934 }
40935
40936
40937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40938   void * jresult ;
40939   Dali::BaseHandle arg1 ;
40940   Dali::BaseHandle *argp1 ;
40941   Dali::PathConstrainer result;
40942
40943   argp1 = (Dali::BaseHandle *)jarg1;
40944   if (!argp1) {
40945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40946     return 0;
40947   }
40948   arg1 = *argp1;
40949   {
40950     try {
40951       result = Dali::PathConstrainer::DownCast(arg1);
40952     } catch (std::out_of_range& e) {
40953       {
40954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (std::exception& e) {
40957       {
40958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40959       };
40960     } catch (...) {
40961       {
40962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40963       };
40964     }
40965   }
40966   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40967   return jresult;
40968 }
40969
40970
40971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40972   void * jresult ;
40973   Dali::PathConstrainer *result = 0 ;
40974
40975   {
40976     try {
40977       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40978     } catch (std::out_of_range& e) {
40979       {
40980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40981       };
40982     } catch (std::exception& e) {
40983       {
40984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40985       };
40986     } catch (...) {
40987       {
40988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40989       };
40990     }
40991   }
40992   jresult = (void *)result;
40993   return jresult;
40994 }
40995
40996
40997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40998   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40999
41000   arg1 = (Dali::PathConstrainer *)jarg1;
41001   {
41002     try {
41003       delete arg1;
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41015       };
41016     }
41017   }
41018 }
41019
41020
41021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41022   void * jresult ;
41023   Dali::PathConstrainer *arg1 = 0 ;
41024   Dali::PathConstrainer *result = 0 ;
41025
41026   arg1 = (Dali::PathConstrainer *)jarg1;
41027   if (!arg1) {
41028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41029     return 0;
41030   }
41031   {
41032     try {
41033       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41034     } catch (std::out_of_range& e) {
41035       {
41036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (std::exception& e) {
41039       {
41040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41041       };
41042     } catch (...) {
41043       {
41044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41045       };
41046     }
41047   }
41048   jresult = (void *)result;
41049   return jresult;
41050 }
41051
41052
41053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41054   void * jresult ;
41055   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41056   Dali::PathConstrainer *arg2 = 0 ;
41057   Dali::PathConstrainer *result = 0 ;
41058
41059   arg1 = (Dali::PathConstrainer *)jarg1;
41060   arg2 = (Dali::PathConstrainer *)jarg2;
41061   if (!arg2) {
41062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41063     return 0;
41064   }
41065   {
41066     try {
41067       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41068     } catch (std::out_of_range& e) {
41069       {
41070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (std::exception& e) {
41073       {
41074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41075       };
41076     } catch (...) {
41077       {
41078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41079       };
41080     }
41081   }
41082   jresult = (void *)result;
41083   return jresult;
41084 }
41085
41086
41087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41088   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41089   SwigValueWrapper< Dali::Property > arg2 ;
41090   SwigValueWrapper< Dali::Property > arg3 ;
41091   Dali::Vector2 *arg4 = 0 ;
41092   Dali::Vector2 *arg5 = 0 ;
41093   Dali::Property *argp2 ;
41094   Dali::Property *argp3 ;
41095
41096   arg1 = (Dali::PathConstrainer *)jarg1;
41097   argp2 = (Dali::Property *)jarg2;
41098   if (!argp2) {
41099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41100     return ;
41101   }
41102   arg2 = *argp2;
41103   argp3 = (Dali::Property *)jarg3;
41104   if (!argp3) {
41105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41106     return ;
41107   }
41108   arg3 = *argp3;
41109   arg4 = (Dali::Vector2 *)jarg4;
41110   if (!arg4) {
41111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41112     return ;
41113   }
41114   arg5 = (Dali::Vector2 *)jarg5;
41115   if (!arg5) {
41116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41117     return ;
41118   }
41119   {
41120     try {
41121       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41122     } catch (std::out_of_range& e) {
41123       {
41124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41125       };
41126     } catch (std::exception& e) {
41127       {
41128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41129       };
41130     } catch (...) {
41131       {
41132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41133       };
41134     }
41135   }
41136 }
41137
41138
41139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41140   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41141   SwigValueWrapper< Dali::Property > arg2 ;
41142   SwigValueWrapper< Dali::Property > arg3 ;
41143   Dali::Vector2 *arg4 = 0 ;
41144   Dali::Property *argp2 ;
41145   Dali::Property *argp3 ;
41146
41147   arg1 = (Dali::PathConstrainer *)jarg1;
41148   argp2 = (Dali::Property *)jarg2;
41149   if (!argp2) {
41150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41151     return ;
41152   }
41153   arg2 = *argp2;
41154   argp3 = (Dali::Property *)jarg3;
41155   if (!argp3) {
41156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41157     return ;
41158   }
41159   arg3 = *argp3;
41160   arg4 = (Dali::Vector2 *)jarg4;
41161   if (!arg4) {
41162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41163     return ;
41164   }
41165   {
41166     try {
41167       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41168     } catch (std::out_of_range& e) {
41169       {
41170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (std::exception& e) {
41173       {
41174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (...) {
41177       {
41178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41179       };
41180     }
41181   }
41182 }
41183
41184
41185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41186   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41187   Dali::Handle *arg2 = 0 ;
41188
41189   arg1 = (Dali::PathConstrainer *)jarg1;
41190   arg2 = (Dali::Handle *)jarg2;
41191   if (!arg2) {
41192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41193     return ;
41194   }
41195   {
41196     try {
41197       (arg1)->Remove(*arg2);
41198     } catch (std::out_of_range& e) {
41199       {
41200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41201       };
41202     } catch (std::exception& e) {
41203       {
41204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41205       };
41206     } catch (...) {
41207       {
41208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41209       };
41210     }
41211   }
41212 }
41213
41214
41215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41216   int jresult ;
41217   Dali::FittingMode::Type result;
41218
41219   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41220   jresult = (int)result;
41221   return jresult;
41222 }
41223
41224
41225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41226   int jresult ;
41227   Dali::SamplingMode::Type result;
41228
41229   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41230   jresult = (int)result;
41231   return jresult;
41232 }
41233
41234
41235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41236   void * jresult ;
41237   Dali::BufferImage *result = 0 ;
41238
41239   {
41240     try {
41241       result = (Dali::BufferImage *)new Dali::BufferImage();
41242     } catch (std::out_of_range& e) {
41243       {
41244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41245       };
41246     } catch (std::exception& e) {
41247       {
41248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41249       };
41250     } catch (...) {
41251       {
41252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41253       };
41254     }
41255   }
41256   jresult = (void *)result;
41257   return jresult;
41258 }
41259
41260
41261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41262   void * jresult ;
41263   unsigned int arg1 ;
41264   unsigned int arg2 ;
41265   Dali::Pixel::Format arg3 ;
41266   Dali::BufferImage result;
41267
41268   arg1 = (unsigned int)jarg1;
41269   arg2 = (unsigned int)jarg2;
41270   arg3 = (Dali::Pixel::Format)jarg3;
41271   {
41272     try {
41273       result = Dali::BufferImage::New(arg1,arg2,arg3);
41274     } catch (std::out_of_range& e) {
41275       {
41276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (std::exception& e) {
41279       {
41280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41281       };
41282     } catch (...) {
41283       {
41284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41285       };
41286     }
41287   }
41288   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41289   return jresult;
41290 }
41291
41292
41293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41294   void * jresult ;
41295   unsigned int arg1 ;
41296   unsigned int arg2 ;
41297   Dali::BufferImage result;
41298
41299   arg1 = (unsigned int)jarg1;
41300   arg2 = (unsigned int)jarg2;
41301   {
41302     try {
41303       result = Dali::BufferImage::New(arg1,arg2);
41304     } catch (std::out_of_range& e) {
41305       {
41306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (std::exception& e) {
41309       {
41310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41311       };
41312     } catch (...) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41315       };
41316     }
41317   }
41318   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41319   return jresult;
41320 }
41321
41322
41323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41324   void * jresult ;
41325   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41326   unsigned int arg2 ;
41327   unsigned int arg3 ;
41328   Dali::Pixel::Format arg4 ;
41329   unsigned int arg5 ;
41330   Dali::BufferImage result;
41331
41332   arg1 = jarg1;
41333   arg2 = (unsigned int)jarg2;
41334   arg3 = (unsigned int)jarg3;
41335   arg4 = (Dali::Pixel::Format)jarg4;
41336   arg5 = (unsigned int)jarg5;
41337   {
41338     try {
41339       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41340     } catch (std::out_of_range& e) {
41341       {
41342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (std::exception& e) {
41345       {
41346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41347       };
41348     } catch (...) {
41349       {
41350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41351       };
41352     }
41353   }
41354   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41355
41356
41357   return jresult;
41358 }
41359
41360
41361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41362   void * jresult ;
41363   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41364   unsigned int arg2 ;
41365   unsigned int arg3 ;
41366   Dali::Pixel::Format arg4 ;
41367   Dali::BufferImage result;
41368
41369   arg1 = jarg1;
41370   arg2 = (unsigned int)jarg2;
41371   arg3 = (unsigned int)jarg3;
41372   arg4 = (Dali::Pixel::Format)jarg4;
41373   {
41374     try {
41375       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41376     } catch (std::out_of_range& e) {
41377       {
41378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (std::exception& e) {
41381       {
41382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (...) {
41385       {
41386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41387       };
41388     }
41389   }
41390   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41391
41392
41393   return jresult;
41394 }
41395
41396
41397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41398   void * jresult ;
41399   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41400   unsigned int arg2 ;
41401   unsigned int arg3 ;
41402   Dali::BufferImage result;
41403
41404   arg1 = jarg1;
41405   arg2 = (unsigned int)jarg2;
41406   arg3 = (unsigned int)jarg3;
41407   {
41408     try {
41409       result = Dali::BufferImage::New(arg1,arg2,arg3);
41410     } catch (std::out_of_range& e) {
41411       {
41412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (std::exception& e) {
41415       {
41416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41417       };
41418     } catch (...) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41421       };
41422     }
41423   }
41424   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41425
41426
41427   return jresult;
41428 }
41429
41430
41431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41432   void * jresult ;
41433   Dali::BaseHandle arg1 ;
41434   Dali::BaseHandle *argp1 ;
41435   Dali::BufferImage result;
41436
41437   argp1 = (Dali::BaseHandle *)jarg1;
41438   if (!argp1) {
41439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41440     return 0;
41441   }
41442   arg1 = *argp1;
41443   {
41444     try {
41445       result = Dali::BufferImage::DownCast(arg1);
41446     } catch (std::out_of_range& e) {
41447       {
41448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41449       };
41450     } catch (std::exception& e) {
41451       {
41452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41453       };
41454     } catch (...) {
41455       {
41456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41457       };
41458     }
41459   }
41460   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41461   return jresult;
41462 }
41463
41464
41465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41466   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41467
41468   arg1 = (Dali::BufferImage *)jarg1;
41469   {
41470     try {
41471       delete arg1;
41472     } catch (std::out_of_range& e) {
41473       {
41474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41475       };
41476     } catch (std::exception& e) {
41477       {
41478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41479       };
41480     } catch (...) {
41481       {
41482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41483       };
41484     }
41485   }
41486 }
41487
41488
41489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41490   void * jresult ;
41491   Dali::BufferImage *arg1 = 0 ;
41492   Dali::BufferImage *result = 0 ;
41493
41494   arg1 = (Dali::BufferImage *)jarg1;
41495   if (!arg1) {
41496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41497     return 0;
41498   }
41499   {
41500     try {
41501       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41502     } catch (std::out_of_range& e) {
41503       {
41504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (std::exception& e) {
41507       {
41508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41509       };
41510     } catch (...) {
41511       {
41512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41513       };
41514     }
41515   }
41516   jresult = (void *)result;
41517   return jresult;
41518 }
41519
41520
41521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41522   void * jresult ;
41523   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41524   Dali::BufferImage *arg2 = 0 ;
41525   Dali::BufferImage *result = 0 ;
41526
41527   arg1 = (Dali::BufferImage *)jarg1;
41528   arg2 = (Dali::BufferImage *)jarg2;
41529   if (!arg2) {
41530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41531     return 0;
41532   }
41533   {
41534     try {
41535       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41536     } catch (std::out_of_range& e) {
41537       {
41538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (std::exception& e) {
41541       {
41542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41543       };
41544     } catch (...) {
41545       {
41546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41547       };
41548     }
41549   }
41550   jresult = (void *)result;
41551   return jresult;
41552 }
41553
41554
41555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41556   void * jresult ;
41557   Dali::BufferImage result;
41558
41559   {
41560     try {
41561       result = Dali::BufferImage::WHITE();
41562     } catch (std::out_of_range& e) {
41563       {
41564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41565       };
41566     } catch (std::exception& e) {
41567       {
41568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41569       };
41570     } catch (...) {
41571       {
41572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41573       };
41574     }
41575   }
41576   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41577   return jresult;
41578 }
41579
41580
41581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41582   void * jresult ;
41583   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41584   Dali::PixelBuffer *result = 0 ;
41585
41586   arg1 = (Dali::BufferImage *)jarg1;
41587   {
41588     try {
41589       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41590     } catch (std::out_of_range& e) {
41591       {
41592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41593       };
41594     } catch (std::exception& e) {
41595       {
41596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41597       };
41598     } catch (...) {
41599       {
41600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41601       };
41602     }
41603   }
41604   jresult = (void *)result;
41605   return jresult;
41606 }
41607
41608
41609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41610   unsigned int jresult ;
41611   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41612   unsigned int result;
41613
41614   arg1 = (Dali::BufferImage *)jarg1;
41615   {
41616     try {
41617       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41618     } catch (std::out_of_range& e) {
41619       {
41620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (std::exception& e) {
41623       {
41624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41625       };
41626     } catch (...) {
41627       {
41628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41629       };
41630     }
41631   }
41632   jresult = result;
41633   return jresult;
41634 }
41635
41636
41637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41638   unsigned int jresult ;
41639   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41640   unsigned int result;
41641
41642   arg1 = (Dali::BufferImage *)jarg1;
41643   {
41644     try {
41645       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41646     } catch (std::out_of_range& e) {
41647       {
41648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41649       };
41650     } catch (std::exception& e) {
41651       {
41652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41653       };
41654     } catch (...) {
41655       {
41656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41657       };
41658     }
41659   }
41660   jresult = result;
41661   return jresult;
41662 }
41663
41664
41665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41666   int jresult ;
41667   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41668   Dali::Pixel::Format result;
41669
41670   arg1 = (Dali::BufferImage *)jarg1;
41671   {
41672     try {
41673       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41674     } catch (std::out_of_range& e) {
41675       {
41676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41677       };
41678     } catch (std::exception& e) {
41679       {
41680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41681       };
41682     } catch (...) {
41683       {
41684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41685       };
41686     }
41687   }
41688   jresult = (int)result;
41689   return jresult;
41690 }
41691
41692
41693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41694   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41695
41696   arg1 = (Dali::BufferImage *)jarg1;
41697   {
41698     try {
41699       (arg1)->Update();
41700     } catch (std::out_of_range& e) {
41701       {
41702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41703       };
41704     } catch (std::exception& e) {
41705       {
41706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41707       };
41708     } catch (...) {
41709       {
41710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41711       };
41712     }
41713   }
41714 }
41715
41716
41717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41718   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41719   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41720   Dali::RectArea *argp2 ;
41721
41722   arg1 = (Dali::BufferImage *)jarg1;
41723   argp2 = (Dali::RectArea *)jarg2;
41724   if (!argp2) {
41725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41726     return ;
41727   }
41728   arg2 = *argp2;
41729   {
41730     try {
41731       (arg1)->Update(arg2);
41732     } catch (std::out_of_range& e) {
41733       {
41734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41735       };
41736     } catch (std::exception& e) {
41737       {
41738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41739       };
41740     } catch (...) {
41741       {
41742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41743       };
41744     }
41745   }
41746 }
41747
41748
41749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41750   unsigned int jresult ;
41751   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41752   bool result;
41753
41754   arg1 = (Dali::BufferImage *)jarg1;
41755   {
41756     try {
41757       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41758     } catch (std::out_of_range& e) {
41759       {
41760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41761       };
41762     } catch (std::exception& e) {
41763       {
41764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41765       };
41766     } catch (...) {
41767       {
41768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41769       };
41770     }
41771   }
41772   jresult = result;
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41778   void * jresult ;
41779   Dali::EncodedBufferImage *result = 0 ;
41780
41781   {
41782     try {
41783       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41784     } catch (std::out_of_range& e) {
41785       {
41786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41787       };
41788     } catch (std::exception& e) {
41789       {
41790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (...) {
41793       {
41794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41795       };
41796     }
41797   }
41798   jresult = (void *)result;
41799   return jresult;
41800 }
41801
41802
41803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41804   void * jresult ;
41805   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41806   std::size_t arg2 ;
41807   Dali::EncodedBufferImage result;
41808
41809   arg1 = (uint8_t *)jarg1;
41810   arg2 = (std::size_t)jarg2;
41811   {
41812     try {
41813       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (...) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41825       };
41826     }
41827   }
41828   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41829   return jresult;
41830 }
41831
41832
41833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41834   void * jresult ;
41835   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41836   std::size_t arg2 ;
41837   Dali::ImageDimensions arg3 ;
41838   Dali::FittingMode::Type arg4 ;
41839   Dali::SamplingMode::Type arg5 ;
41840   bool arg6 ;
41841   Dali::ImageDimensions *argp3 ;
41842   Dali::EncodedBufferImage result;
41843
41844   arg1 = (uint8_t *)jarg1;
41845   arg2 = (std::size_t)jarg2;
41846   argp3 = (Dali::ImageDimensions *)jarg3;
41847   if (!argp3) {
41848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41849     return 0;
41850   }
41851   arg3 = *argp3;
41852   arg4 = (Dali::FittingMode::Type)jarg4;
41853   arg5 = (Dali::SamplingMode::Type)jarg5;
41854   arg6 = jarg6 ? true : false;
41855   {
41856     try {
41857       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41858     } catch (std::out_of_range& e) {
41859       {
41860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (std::exception& e) {
41863       {
41864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (...) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41869       };
41870     }
41871   }
41872   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41873   return jresult;
41874 }
41875
41876
41877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41878   void * jresult ;
41879   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41880   std::size_t arg2 ;
41881   Dali::ImageDimensions arg3 ;
41882   Dali::FittingMode::Type arg4 ;
41883   Dali::SamplingMode::Type arg5 ;
41884   Dali::ImageDimensions *argp3 ;
41885   Dali::EncodedBufferImage result;
41886
41887   arg1 = (uint8_t *)jarg1;
41888   arg2 = (std::size_t)jarg2;
41889   argp3 = (Dali::ImageDimensions *)jarg3;
41890   if (!argp3) {
41891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41892     return 0;
41893   }
41894   arg3 = *argp3;
41895   arg4 = (Dali::FittingMode::Type)jarg4;
41896   arg5 = (Dali::SamplingMode::Type)jarg5;
41897   {
41898     try {
41899       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41900     } catch (std::out_of_range& e) {
41901       {
41902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (std::exception& e) {
41905       {
41906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (...) {
41909       {
41910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41911       };
41912     }
41913   }
41914   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41915   return jresult;
41916 }
41917
41918
41919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41920   void * jresult ;
41921   Dali::BaseHandle arg1 ;
41922   Dali::BaseHandle *argp1 ;
41923   Dali::EncodedBufferImage result;
41924
41925   argp1 = (Dali::BaseHandle *)jarg1;
41926   if (!argp1) {
41927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41928     return 0;
41929   }
41930   arg1 = *argp1;
41931   {
41932     try {
41933       result = Dali::EncodedBufferImage::DownCast(arg1);
41934     } catch (std::out_of_range& e) {
41935       {
41936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (std::exception& e) {
41939       {
41940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41941       };
41942     } catch (...) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41945       };
41946     }
41947   }
41948   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41949   return jresult;
41950 }
41951
41952
41953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41954   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41955
41956   arg1 = (Dali::EncodedBufferImage *)jarg1;
41957   {
41958     try {
41959       delete arg1;
41960     } catch (std::out_of_range& e) {
41961       {
41962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41963       };
41964     } catch (std::exception& e) {
41965       {
41966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41967       };
41968     } catch (...) {
41969       {
41970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41971       };
41972     }
41973   }
41974 }
41975
41976
41977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41978   void * jresult ;
41979   Dali::EncodedBufferImage *arg1 = 0 ;
41980   Dali::EncodedBufferImage *result = 0 ;
41981
41982   arg1 = (Dali::EncodedBufferImage *)jarg1;
41983   if (!arg1) {
41984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41985     return 0;
41986   }
41987   {
41988     try {
41989       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41990     } catch (std::out_of_range& e) {
41991       {
41992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41993       };
41994     } catch (std::exception& e) {
41995       {
41996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41997       };
41998     } catch (...) {
41999       {
42000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42001       };
42002     }
42003   }
42004   jresult = (void *)result;
42005   return jresult;
42006 }
42007
42008
42009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42010   void * jresult ;
42011   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42012   Dali::EncodedBufferImage *arg2 = 0 ;
42013   Dali::EncodedBufferImage *result = 0 ;
42014
42015   arg1 = (Dali::EncodedBufferImage *)jarg1;
42016   arg2 = (Dali::EncodedBufferImage *)jarg2;
42017   if (!arg2) {
42018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42019     return 0;
42020   }
42021   {
42022     try {
42023       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42024     } catch (std::out_of_range& e) {
42025       {
42026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42027       };
42028     } catch (std::exception& e) {
42029       {
42030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42031       };
42032     } catch (...) {
42033       {
42034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42035       };
42036     }
42037   }
42038   jresult = (void *)result;
42039   return jresult;
42040 }
42041
42042
42043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42044   void * jresult ;
42045   Dali::NativeImage *result = 0 ;
42046
42047   {
42048     try {
42049       result = (Dali::NativeImage *)new Dali::NativeImage();
42050     } catch (std::out_of_range& e) {
42051       {
42052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42053       };
42054     } catch (std::exception& e) {
42055       {
42056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42057       };
42058     } catch (...) {
42059       {
42060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42061       };
42062     }
42063   }
42064   jresult = (void *)result;
42065   return jresult;
42066 }
42067
42068
42069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42070   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42071
42072   arg1 = (Dali::NativeImage *)jarg1;
42073   {
42074     try {
42075       delete arg1;
42076     } catch (std::out_of_range& e) {
42077       {
42078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42079       };
42080     } catch (std::exception& e) {
42081       {
42082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42083       };
42084     } catch (...) {
42085       {
42086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42087       };
42088     }
42089   }
42090 }
42091
42092
42093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42094   void * jresult ;
42095   Dali::NativeImage *arg1 = 0 ;
42096   Dali::NativeImage *result = 0 ;
42097
42098   arg1 = (Dali::NativeImage *)jarg1;
42099   if (!arg1) {
42100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42101     return 0;
42102   }
42103   {
42104     try {
42105       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42106     } catch (std::out_of_range& e) {
42107       {
42108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42109       };
42110     } catch (std::exception& e) {
42111       {
42112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42113       };
42114     } catch (...) {
42115       {
42116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42117       };
42118     }
42119   }
42120   jresult = (void *)result;
42121   return jresult;
42122 }
42123
42124
42125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42126   void * jresult ;
42127   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42128   Dali::NativeImage *arg2 = 0 ;
42129   Dali::NativeImage *result = 0 ;
42130
42131   arg1 = (Dali::NativeImage *)jarg1;
42132   arg2 = (Dali::NativeImage *)jarg2;
42133   if (!arg2) {
42134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42135     return 0;
42136   }
42137   {
42138     try {
42139       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42140     } catch (std::out_of_range& e) {
42141       {
42142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42143       };
42144     } catch (std::exception& e) {
42145       {
42146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42147       };
42148     } catch (...) {
42149       {
42150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42151       };
42152     }
42153   }
42154   jresult = (void *)result;
42155   return jresult;
42156 }
42157
42158
42159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42160   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42161
42162   arg1 = (Dali::NativeImage *)jarg1;
42163   {
42164     try {
42165       (arg1)->CreateGlTexture();
42166     } catch (std::out_of_range& e) {
42167       {
42168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (std::exception& e) {
42171       {
42172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42173       };
42174     } catch (...) {
42175       {
42176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42177       };
42178     }
42179   }
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42184   void * jresult ;
42185   NativeImageInterface *arg1 = 0 ;
42186   Dali::NativeImage result;
42187
42188   arg1 = (NativeImageInterface *)jarg1;
42189   if (!arg1) {
42190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42191     return 0;
42192   }
42193   {
42194     try {
42195       result = Dali::NativeImage::New(*arg1);
42196     } catch (std::out_of_range& e) {
42197       {
42198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42199       };
42200     } catch (std::exception& e) {
42201       {
42202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42203       };
42204     } catch (...) {
42205       {
42206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42207       };
42208     }
42209   }
42210   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42211   return jresult;
42212 }
42213
42214
42215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42216   void * jresult ;
42217   Dali::BaseHandle arg1 ;
42218   Dali::BaseHandle *argp1 ;
42219   Dali::NativeImage result;
42220
42221   argp1 = (Dali::BaseHandle *)jarg1;
42222   if (!argp1) {
42223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42224     return 0;
42225   }
42226   arg1 = *argp1;
42227   {
42228     try {
42229       result = Dali::NativeImage::DownCast(arg1);
42230     } catch (std::out_of_range& e) {
42231       {
42232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42233       };
42234     } catch (std::exception& e) {
42235       {
42236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42237       };
42238     } catch (...) {
42239       {
42240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42241       };
42242     }
42243   }
42244   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42245   return jresult;
42246 }
42247
42248
42249 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42250   char * jresult ;
42251   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42252   char *result = 0 ;
42253
42254   arg1 = (Dali::NativeImage *)jarg1;
42255   {
42256     try {
42257       result = (char *)(arg1)->GetCustomFragmentPreFix();
42258     } catch (std::out_of_range& e) {
42259       {
42260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (std::exception& e) {
42263       {
42264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272   jresult = SWIG_csharp_string_callback((const char *)result);
42273   return jresult;
42274 }
42275
42276
42277 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42278   char * jresult ;
42279   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42280   char *result = 0 ;
42281
42282   arg1 = (Dali::NativeImage *)jarg1;
42283   {
42284     try {
42285       result = (char *)(arg1)->GetCustomSamplerTypename();
42286     } catch (std::out_of_range& e) {
42287       {
42288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42289       };
42290     } catch (std::exception& e) {
42291       {
42292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (...) {
42295       {
42296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42297       };
42298     }
42299   }
42300   jresult = SWIG_csharp_string_callback((const char *)result);
42301   return jresult;
42302 }
42303
42304
42305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42306   unsigned int jresult ;
42307   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42308   bool result;
42309
42310   arg1 = (Dali::NativeImageInterface *)jarg1;
42311   {
42312     try {
42313       result = (bool)(arg1)->GlExtensionCreate();
42314     } catch (std::out_of_range& e) {
42315       {
42316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (std::exception& e) {
42319       {
42320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328   jresult = result;
42329   return jresult;
42330 }
42331
42332
42333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42334   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42335
42336   arg1 = (Dali::NativeImageInterface *)jarg1;
42337   {
42338     try {
42339       (arg1)->GlExtensionDestroy();
42340     } catch (std::out_of_range& e) {
42341       {
42342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42343       };
42344     } catch (std::exception& e) {
42345       {
42346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42347       };
42348     } catch (...) {
42349       {
42350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42351       };
42352     }
42353   }
42354 }
42355
42356
42357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42358   unsigned int jresult ;
42359   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42360   unsigned int result;
42361
42362   arg1 = (Dali::NativeImageInterface *)jarg1;
42363   {
42364     try {
42365       result = (unsigned int)(arg1)->TargetTexture();
42366     } catch (std::out_of_range& e) {
42367       {
42368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (std::exception& e) {
42371       {
42372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (...) {
42375       {
42376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42377       };
42378     }
42379   }
42380   jresult = result;
42381   return jresult;
42382 }
42383
42384
42385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42387
42388   arg1 = (Dali::NativeImageInterface *)jarg1;
42389   {
42390     try {
42391       (arg1)->PrepareTexture();
42392     } catch (std::out_of_range& e) {
42393       {
42394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42395       };
42396     } catch (std::exception& e) {
42397       {
42398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42399       };
42400     } catch (...) {
42401       {
42402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42403       };
42404     }
42405   }
42406 }
42407
42408
42409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42410   unsigned int jresult ;
42411   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42412   unsigned int result;
42413
42414   arg1 = (Dali::NativeImageInterface *)jarg1;
42415   {
42416     try {
42417       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42418     } catch (std::out_of_range& e) {
42419       {
42420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42421       };
42422     } catch (std::exception& e) {
42423       {
42424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42425       };
42426     } catch (...) {
42427       {
42428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42429       };
42430     }
42431   }
42432   jresult = result;
42433   return jresult;
42434 }
42435
42436
42437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42438   unsigned int jresult ;
42439   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42440   unsigned int result;
42441
42442   arg1 = (Dali::NativeImageInterface *)jarg1;
42443   {
42444     try {
42445       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42446     } catch (std::out_of_range& e) {
42447       {
42448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (std::exception& e) {
42451       {
42452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42453       };
42454     } catch (...) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42457       };
42458     }
42459   }
42460   jresult = result;
42461   return jresult;
42462 }
42463
42464
42465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42466   unsigned int jresult ;
42467   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42468   bool result;
42469
42470   arg1 = (Dali::NativeImageInterface *)jarg1;
42471   {
42472     try {
42473       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42474     } catch (std::out_of_range& e) {
42475       {
42476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42477       };
42478     } catch (std::exception& e) {
42479       {
42480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42481       };
42482     } catch (...) {
42483       {
42484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42485       };
42486     }
42487   }
42488   jresult = result;
42489   return jresult;
42490 }
42491
42492
42493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42494   void * jresult ;
42495   std::string *arg1 = 0 ;
42496   Dali::ImageDimensions result;
42497
42498   if (!jarg1) {
42499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42500     return 0;
42501   }
42502   std::string arg1_str(jarg1);
42503   arg1 = &arg1_str;
42504   {
42505     try {
42506       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42507     } catch (std::out_of_range& e) {
42508       {
42509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42510       };
42511     } catch (std::exception& e) {
42512       {
42513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42514       };
42515     } catch (...) {
42516       {
42517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42518       };
42519     }
42520   }
42521   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42522
42523   //argout typemap for const std::string&
42524
42525   return jresult;
42526 }
42527
42528
42529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42530   void * jresult ;
42531   Dali::ResourceImage *result = 0 ;
42532
42533   {
42534     try {
42535       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42536     } catch (std::out_of_range& e) {
42537       {
42538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (std::exception& e) {
42541       {
42542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42543       };
42544     } catch (...) {
42545       {
42546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42547       };
42548     }
42549   }
42550   jresult = (void *)result;
42551   return jresult;
42552 }
42553
42554
42555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42556   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42557
42558   arg1 = (Dali::ResourceImage *)jarg1;
42559   {
42560     try {
42561       delete arg1;
42562     } catch (std::out_of_range& e) {
42563       {
42564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42565       };
42566     } catch (std::exception& e) {
42567       {
42568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42573       };
42574     }
42575   }
42576 }
42577
42578
42579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42580   void * jresult ;
42581   Dali::ResourceImage *arg1 = 0 ;
42582   Dali::ResourceImage *result = 0 ;
42583
42584   arg1 = (Dali::ResourceImage *)jarg1;
42585   if (!arg1) {
42586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42587     return 0;
42588   }
42589   {
42590     try {
42591       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42592     } catch (std::out_of_range& e) {
42593       {
42594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (std::exception& e) {
42597       {
42598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42599       };
42600     } catch (...) {
42601       {
42602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42603       };
42604     }
42605   }
42606   jresult = (void *)result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42612   void * jresult ;
42613   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42614   Dali::ResourceImage *arg2 = 0 ;
42615   Dali::ResourceImage *result = 0 ;
42616
42617   arg1 = (Dali::ResourceImage *)jarg1;
42618   arg2 = (Dali::ResourceImage *)jarg2;
42619   if (!arg2) {
42620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42621     return 0;
42622   }
42623   {
42624     try {
42625       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42626     } catch (std::out_of_range& e) {
42627       {
42628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42629       };
42630     } catch (std::exception& e) {
42631       {
42632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42633       };
42634     } catch (...) {
42635       {
42636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42637       };
42638     }
42639   }
42640   jresult = (void *)result;
42641   return jresult;
42642 }
42643
42644
42645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42646   void * jresult ;
42647   std::string *arg1 = 0 ;
42648   bool arg2 ;
42649   Dali::ResourceImage result;
42650
42651   if (!jarg1) {
42652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42653     return 0;
42654   }
42655   std::string arg1_str(jarg1);
42656   arg1 = &arg1_str;
42657   arg2 = jarg2 ? true : false;
42658   {
42659     try {
42660       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42661     } catch (std::out_of_range& e) {
42662       {
42663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42664       };
42665     } catch (std::exception& e) {
42666       {
42667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42668       };
42669     } catch (...) {
42670       {
42671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42672       };
42673     }
42674   }
42675   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42676
42677   //argout typemap for const std::string&
42678
42679   return jresult;
42680 }
42681
42682
42683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42684   void * jresult ;
42685   std::string *arg1 = 0 ;
42686   Dali::ResourceImage result;
42687
42688   if (!jarg1) {
42689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42690     return 0;
42691   }
42692   std::string arg1_str(jarg1);
42693   arg1 = &arg1_str;
42694   {
42695     try {
42696       result = Dali::ResourceImage::New((std::string const &)*arg1);
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42704       };
42705     } catch (...) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42708       };
42709     }
42710   }
42711   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42712
42713   //argout typemap for const std::string&
42714
42715   return jresult;
42716 }
42717
42718
42719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42720   void * jresult ;
42721   std::string *arg1 = 0 ;
42722   Dali::ImageDimensions arg2 ;
42723   Dali::FittingMode::Type arg3 ;
42724   Dali::SamplingMode::Type arg4 ;
42725   bool arg5 ;
42726   Dali::ImageDimensions *argp2 ;
42727   Dali::ResourceImage result;
42728
42729   if (!jarg1) {
42730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42731     return 0;
42732   }
42733   std::string arg1_str(jarg1);
42734   arg1 = &arg1_str;
42735   argp2 = (Dali::ImageDimensions *)jarg2;
42736   if (!argp2) {
42737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42738     return 0;
42739   }
42740   arg2 = *argp2;
42741   arg3 = (Dali::FittingMode::Type)jarg3;
42742   arg4 = (Dali::SamplingMode::Type)jarg4;
42743   arg5 = jarg5 ? true : false;
42744   {
42745     try {
42746       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42747     } catch (std::out_of_range& e) {
42748       {
42749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42750       };
42751     } catch (std::exception& e) {
42752       {
42753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42754       };
42755     } catch (...) {
42756       {
42757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42758       };
42759     }
42760   }
42761   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42762
42763   //argout typemap for const std::string&
42764
42765   return jresult;
42766 }
42767
42768
42769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42770   void * jresult ;
42771   std::string *arg1 = 0 ;
42772   Dali::ImageDimensions arg2 ;
42773   Dali::FittingMode::Type arg3 ;
42774   Dali::SamplingMode::Type arg4 ;
42775   Dali::ImageDimensions *argp2 ;
42776   Dali::ResourceImage result;
42777
42778   if (!jarg1) {
42779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42780     return 0;
42781   }
42782   std::string arg1_str(jarg1);
42783   arg1 = &arg1_str;
42784   argp2 = (Dali::ImageDimensions *)jarg2;
42785   if (!argp2) {
42786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42787     return 0;
42788   }
42789   arg2 = *argp2;
42790   arg3 = (Dali::FittingMode::Type)jarg3;
42791   arg4 = (Dali::SamplingMode::Type)jarg4;
42792   {
42793     try {
42794       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42795     } catch (std::out_of_range& e) {
42796       {
42797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (std::exception& e) {
42800       {
42801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42802       };
42803     } catch (...) {
42804       {
42805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42806       };
42807     }
42808   }
42809   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42810
42811   //argout typemap for const std::string&
42812
42813   return jresult;
42814 }
42815
42816
42817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42818   void * jresult ;
42819   std::string *arg1 = 0 ;
42820   Dali::ImageDimensions arg2 ;
42821   Dali::FittingMode::Type arg3 ;
42822   Dali::ImageDimensions *argp2 ;
42823   Dali::ResourceImage result;
42824
42825   if (!jarg1) {
42826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42827     return 0;
42828   }
42829   std::string arg1_str(jarg1);
42830   arg1 = &arg1_str;
42831   argp2 = (Dali::ImageDimensions *)jarg2;
42832   if (!argp2) {
42833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42834     return 0;
42835   }
42836   arg2 = *argp2;
42837   arg3 = (Dali::FittingMode::Type)jarg3;
42838   {
42839     try {
42840       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42841     } catch (std::out_of_range& e) {
42842       {
42843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42844       };
42845     } catch (std::exception& e) {
42846       {
42847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42848       };
42849     } catch (...) {
42850       {
42851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42852       };
42853     }
42854   }
42855   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42856
42857   //argout typemap for const std::string&
42858
42859   return jresult;
42860 }
42861
42862
42863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42864   void * jresult ;
42865   std::string *arg1 = 0 ;
42866   Dali::ImageDimensions arg2 ;
42867   Dali::ImageDimensions *argp2 ;
42868   Dali::ResourceImage result;
42869
42870   if (!jarg1) {
42871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42872     return 0;
42873   }
42874   std::string arg1_str(jarg1);
42875   arg1 = &arg1_str;
42876   argp2 = (Dali::ImageDimensions *)jarg2;
42877   if (!argp2) {
42878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42879     return 0;
42880   }
42881   arg2 = *argp2;
42882   {
42883     try {
42884       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42885     } catch (std::out_of_range& e) {
42886       {
42887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (std::exception& e) {
42890       {
42891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42892       };
42893     } catch (...) {
42894       {
42895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42896       };
42897     }
42898   }
42899   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42900
42901   //argout typemap for const std::string&
42902
42903   return jresult;
42904 }
42905
42906
42907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42908   void * jresult ;
42909   Dali::BaseHandle arg1 ;
42910   Dali::BaseHandle *argp1 ;
42911   Dali::ResourceImage result;
42912
42913   argp1 = (Dali::BaseHandle *)jarg1;
42914   if (!argp1) {
42915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42916     return 0;
42917   }
42918   arg1 = *argp1;
42919   {
42920     try {
42921       result = Dali::ResourceImage::DownCast(arg1);
42922     } catch (std::out_of_range& e) {
42923       {
42924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (std::exception& e) {
42927       {
42928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (...) {
42931       {
42932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42933       };
42934     }
42935   }
42936   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42937   return jresult;
42938 }
42939
42940
42941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42942   int jresult ;
42943   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42944   Dali::LoadingState result;
42945
42946   arg1 = (Dali::ResourceImage *)jarg1;
42947   {
42948     try {
42949       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42950     } catch (std::out_of_range& e) {
42951       {
42952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (std::exception& e) {
42955       {
42956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42957       };
42958     } catch (...) {
42959       {
42960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42961       };
42962     }
42963   }
42964   jresult = (int)result;
42965   return jresult;
42966 }
42967
42968
42969 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42970   char * jresult ;
42971   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42972   std::string result;
42973
42974   arg1 = (Dali::ResourceImage *)jarg1;
42975   {
42976     try {
42977       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42978     } catch (std::out_of_range& e) {
42979       {
42980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42981       };
42982     } catch (std::exception& e) {
42983       {
42984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (...) {
42987       {
42988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42989       };
42990     }
42991   }
42992   jresult = SWIG_csharp_string_callback((&result)->c_str());
42993   return jresult;
42994 }
42995
42996
42997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42998   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42999
43000   arg1 = (Dali::ResourceImage *)jarg1;
43001   {
43002     try {
43003       (arg1)->Reload();
43004     } catch (std::out_of_range& e) {
43005       {
43006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43007       };
43008     } catch (std::exception& e) {
43009       {
43010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43011       };
43012     } catch (...) {
43013       {
43014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43015       };
43016     }
43017   }
43018 }
43019
43020
43021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43022   void * jresult ;
43023   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43024   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43025
43026   arg1 = (Dali::ResourceImage *)jarg1;
43027   {
43028     try {
43029       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43037       };
43038     } catch (...) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43041       };
43042     }
43043   }
43044   jresult = (void *)result;
43045   return jresult;
43046 }
43047
43048
43049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43050   void * jresult ;
43051   Dali::FrameBufferImage *result = 0 ;
43052
43053   {
43054     try {
43055       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43056     } catch (std::out_of_range& e) {
43057       {
43058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (std::exception& e) {
43061       {
43062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43063       };
43064     } catch (...) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43067       };
43068     }
43069   }
43070   jresult = (void *)result;
43071   return jresult;
43072 }
43073
43074
43075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43076   void * jresult ;
43077   unsigned int arg1 ;
43078   unsigned int arg2 ;
43079   Dali::Pixel::Format arg3 ;
43080   Dali::RenderBuffer::Format arg4 ;
43081   Dali::FrameBufferImage result;
43082
43083   arg1 = (unsigned int)jarg1;
43084   arg2 = (unsigned int)jarg2;
43085   arg3 = (Dali::Pixel::Format)jarg3;
43086   arg4 = (Dali::RenderBuffer::Format)jarg4;
43087   {
43088     try {
43089       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43090     } catch (std::out_of_range& e) {
43091       {
43092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (std::exception& e) {
43095       {
43096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43101       };
43102     }
43103   }
43104   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43105   return jresult;
43106 }
43107
43108
43109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43110   void * jresult ;
43111   unsigned int arg1 ;
43112   unsigned int arg2 ;
43113   Dali::Pixel::Format arg3 ;
43114   Dali::FrameBufferImage result;
43115
43116   arg1 = (unsigned int)jarg1;
43117   arg2 = (unsigned int)jarg2;
43118   arg3 = (Dali::Pixel::Format)jarg3;
43119   {
43120     try {
43121       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43122     } catch (std::out_of_range& e) {
43123       {
43124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (std::exception& e) {
43127       {
43128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43129       };
43130     } catch (...) {
43131       {
43132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43133       };
43134     }
43135   }
43136   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43137   return jresult;
43138 }
43139
43140
43141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43142   void * jresult ;
43143   unsigned int arg1 ;
43144   unsigned int arg2 ;
43145   Dali::FrameBufferImage result;
43146
43147   arg1 = (unsigned int)jarg1;
43148   arg2 = (unsigned int)jarg2;
43149   {
43150     try {
43151       result = Dali::FrameBufferImage::New(arg1,arg2);
43152     } catch (std::out_of_range& e) {
43153       {
43154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43155       };
43156     } catch (std::exception& e) {
43157       {
43158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43159       };
43160     } catch (...) {
43161       {
43162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43163       };
43164     }
43165   }
43166   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43167   return jresult;
43168 }
43169
43170
43171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43172   void * jresult ;
43173   unsigned int arg1 ;
43174   Dali::FrameBufferImage result;
43175
43176   arg1 = (unsigned int)jarg1;
43177   {
43178     try {
43179       result = Dali::FrameBufferImage::New(arg1);
43180     } catch (std::out_of_range& e) {
43181       {
43182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (std::exception& e) {
43185       {
43186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (...) {
43189       {
43190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43191       };
43192     }
43193   }
43194   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43195   return jresult;
43196 }
43197
43198
43199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43200   void * jresult ;
43201   Dali::FrameBufferImage result;
43202
43203   {
43204     try {
43205       result = Dali::FrameBufferImage::New();
43206     } catch (std::out_of_range& e) {
43207       {
43208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43209       };
43210     } catch (std::exception& e) {
43211       {
43212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43213       };
43214     } catch (...) {
43215       {
43216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43217       };
43218     }
43219   }
43220   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43221   return jresult;
43222 }
43223
43224
43225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43226   void * jresult ;
43227   Dali::NativeImageInterface *arg1 = 0 ;
43228   Dali::FrameBufferImage result;
43229
43230   arg1 = (Dali::NativeImageInterface *)jarg1;
43231   if (!arg1) {
43232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43233     return 0;
43234   }
43235   {
43236     try {
43237       result = Dali::FrameBufferImage::New(*arg1);
43238     } catch (std::out_of_range& e) {
43239       {
43240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43241       };
43242     } catch (std::exception& e) {
43243       {
43244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43245       };
43246     } catch (...) {
43247       {
43248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43249       };
43250     }
43251   }
43252   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43253   return jresult;
43254 }
43255
43256
43257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43258   void * jresult ;
43259   Dali::BaseHandle arg1 ;
43260   Dali::BaseHandle *argp1 ;
43261   Dali::FrameBufferImage result;
43262
43263   argp1 = (Dali::BaseHandle *)jarg1;
43264   if (!argp1) {
43265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43266     return 0;
43267   }
43268   arg1 = *argp1;
43269   {
43270     try {
43271       result = Dali::FrameBufferImage::DownCast(arg1);
43272     } catch (std::out_of_range& e) {
43273       {
43274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43275       };
43276     } catch (std::exception& e) {
43277       {
43278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43279       };
43280     } catch (...) {
43281       {
43282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43283       };
43284     }
43285   }
43286   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43287   return jresult;
43288 }
43289
43290
43291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43292   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43293
43294   arg1 = (Dali::FrameBufferImage *)jarg1;
43295   {
43296     try {
43297       delete arg1;
43298     } catch (std::out_of_range& e) {
43299       {
43300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (std::exception& e) {
43303       {
43304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43305       };
43306     } catch (...) {
43307       {
43308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43309       };
43310     }
43311   }
43312 }
43313
43314
43315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43316   void * jresult ;
43317   Dali::FrameBufferImage *arg1 = 0 ;
43318   Dali::FrameBufferImage *result = 0 ;
43319
43320   arg1 = (Dali::FrameBufferImage *)jarg1;
43321   if (!arg1) {
43322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43323     return 0;
43324   }
43325   {
43326     try {
43327       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43328     } catch (std::out_of_range& e) {
43329       {
43330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43331       };
43332     } catch (std::exception& e) {
43333       {
43334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43335       };
43336     } catch (...) {
43337       {
43338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43339       };
43340     }
43341   }
43342   jresult = (void *)result;
43343   return jresult;
43344 }
43345
43346
43347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43348   void * jresult ;
43349   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43350   Dali::FrameBufferImage *arg2 = 0 ;
43351   Dali::FrameBufferImage *result = 0 ;
43352
43353   arg1 = (Dali::FrameBufferImage *)jarg1;
43354   arg2 = (Dali::FrameBufferImage *)jarg2;
43355   if (!arg2) {
43356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43357     return 0;
43358   }
43359   {
43360     try {
43361       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43362     } catch (std::out_of_range& e) {
43363       {
43364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43365       };
43366     } catch (std::exception& e) {
43367       {
43368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43369       };
43370     } catch (...) {
43371       {
43372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43373       };
43374     }
43375   }
43376   jresult = (void *)result;
43377   return jresult;
43378 }
43379
43380
43381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43382   void * jresult ;
43383   Dali::NinePatchImage *result = 0 ;
43384
43385   {
43386     try {
43387       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43388     } catch (std::out_of_range& e) {
43389       {
43390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43391       };
43392     } catch (std::exception& e) {
43393       {
43394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43395       };
43396     } catch (...) {
43397       {
43398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43399       };
43400     }
43401   }
43402   jresult = (void *)result;
43403   return jresult;
43404 }
43405
43406
43407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43408   void * jresult ;
43409   std::string *arg1 = 0 ;
43410   Dali::NinePatchImage result;
43411
43412   if (!jarg1) {
43413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43414     return 0;
43415   }
43416   std::string arg1_str(jarg1);
43417   arg1 = &arg1_str;
43418   {
43419     try {
43420       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43421     } catch (std::out_of_range& e) {
43422       {
43423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43424       };
43425     } catch (std::exception& e) {
43426       {
43427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43428       };
43429     } catch (...) {
43430       {
43431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43432       };
43433     }
43434   }
43435   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43436
43437   //argout typemap for const std::string&
43438
43439   return jresult;
43440 }
43441
43442
43443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43444   void * jresult ;
43445   Dali::BaseHandle arg1 ;
43446   Dali::BaseHandle *argp1 ;
43447   Dali::NinePatchImage result;
43448
43449   argp1 = (Dali::BaseHandle *)jarg1;
43450   if (!argp1) {
43451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43452     return 0;
43453   }
43454   arg1 = *argp1;
43455   {
43456     try {
43457       result = Dali::NinePatchImage::DownCast(arg1);
43458     } catch (std::out_of_range& e) {
43459       {
43460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43461       };
43462     } catch (std::exception& e) {
43463       {
43464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43465       };
43466     } catch (...) {
43467       {
43468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43469       };
43470     }
43471   }
43472   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43473   return jresult;
43474 }
43475
43476
43477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43478   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43479
43480   arg1 = (Dali::NinePatchImage *)jarg1;
43481   {
43482     try {
43483       delete arg1;
43484     } catch (std::out_of_range& e) {
43485       {
43486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43487       };
43488     } catch (std::exception& e) {
43489       {
43490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43491       };
43492     } catch (...) {
43493       {
43494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43495       };
43496     }
43497   }
43498 }
43499
43500
43501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43502   void * jresult ;
43503   Dali::NinePatchImage *arg1 = 0 ;
43504   Dali::NinePatchImage *result = 0 ;
43505
43506   arg1 = (Dali::NinePatchImage *)jarg1;
43507   if (!arg1) {
43508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43509     return 0;
43510   }
43511   {
43512     try {
43513       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43514     } catch (std::out_of_range& e) {
43515       {
43516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43517       };
43518     } catch (std::exception& e) {
43519       {
43520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43521       };
43522     } catch (...) {
43523       {
43524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43525       };
43526     }
43527   }
43528   jresult = (void *)result;
43529   return jresult;
43530 }
43531
43532
43533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43534   void * jresult ;
43535   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43536   Dali::NinePatchImage *arg2 = 0 ;
43537   Dali::NinePatchImage *result = 0 ;
43538
43539   arg1 = (Dali::NinePatchImage *)jarg1;
43540   arg2 = (Dali::NinePatchImage *)jarg2;
43541   if (!arg2) {
43542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43543     return 0;
43544   }
43545   {
43546     try {
43547       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43548     } catch (std::out_of_range& e) {
43549       {
43550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43551       };
43552     } catch (std::exception& e) {
43553       {
43554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43555       };
43556     } catch (...) {
43557       {
43558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43559       };
43560     }
43561   }
43562   jresult = (void *)result;
43563   return jresult;
43564 }
43565
43566
43567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43568   void * jresult ;
43569   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43570   Dali::Vector4 result;
43571
43572   arg1 = (Dali::NinePatchImage *)jarg1;
43573   {
43574     try {
43575       result = (arg1)->GetStretchBorders();
43576     } catch (std::out_of_range& e) {
43577       {
43578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43579       };
43580     } catch (std::exception& e) {
43581       {
43582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43583       };
43584     } catch (...) {
43585       {
43586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43587       };
43588     }
43589   }
43590   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43591   return jresult;
43592 }
43593
43594
43595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43596   void * jresult ;
43597   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43598   Dali::NinePatchImage::StretchRanges *result = 0 ;
43599
43600   arg1 = (Dali::NinePatchImage *)jarg1;
43601   {
43602     try {
43603       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43604     } catch (std::out_of_range& e) {
43605       {
43606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43607       };
43608     } catch (std::exception& e) {
43609       {
43610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43611       };
43612     } catch (...) {
43613       {
43614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43615       };
43616     }
43617   }
43618   jresult = (void *)result;
43619   return jresult;
43620 }
43621
43622
43623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43624   void * jresult ;
43625   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43626   Dali::NinePatchImage::StretchRanges *result = 0 ;
43627
43628   arg1 = (Dali::NinePatchImage *)jarg1;
43629   {
43630     try {
43631       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43632     } catch (std::out_of_range& e) {
43633       {
43634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43635       };
43636     } catch (std::exception& e) {
43637       {
43638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43639       };
43640     } catch (...) {
43641       {
43642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43643       };
43644     }
43645   }
43646   jresult = (void *)result;
43647   return jresult;
43648 }
43649
43650
43651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43652   void * jresult ;
43653   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43654   Dali::Rect< int > result;
43655
43656   arg1 = (Dali::NinePatchImage *)jarg1;
43657   {
43658     try {
43659       result = (arg1)->GetChildRectangle();
43660     } catch (std::out_of_range& e) {
43661       {
43662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (std::exception& e) {
43665       {
43666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43667       };
43668     } catch (...) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43671       };
43672     }
43673   }
43674   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43680   void * jresult ;
43681   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43682   Dali::BufferImage result;
43683
43684   arg1 = (Dali::NinePatchImage *)jarg1;
43685   {
43686     try {
43687       result = (arg1)->CreateCroppedBufferImage();
43688     } catch (std::out_of_range& e) {
43689       {
43690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43691       };
43692     } catch (std::exception& e) {
43693       {
43694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43695       };
43696     } catch (...) {
43697       {
43698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43699       };
43700     }
43701   }
43702   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43703   return jresult;
43704 }
43705
43706
43707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43708   unsigned int jresult ;
43709   std::string *arg1 = 0 ;
43710   bool result;
43711
43712   if (!jarg1) {
43713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43714     return 0;
43715   }
43716   std::string arg1_str(jarg1);
43717   arg1 = &arg1_str;
43718   {
43719     try {
43720       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43721     } catch (std::out_of_range& e) {
43722       {
43723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (std::exception& e) {
43726       {
43727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43732       };
43733     }
43734   }
43735   jresult = result;
43736
43737   //argout typemap for const std::string&
43738
43739   return jresult;
43740 }
43741
43742
43743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43744   int jresult ;
43745   int result;
43746
43747   result = (int)Dali::CameraActor::Property::TYPE;
43748   jresult = (int)result;
43749   return jresult;
43750 }
43751
43752
43753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43754   int jresult ;
43755   int result;
43756
43757   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43758   jresult = (int)result;
43759   return jresult;
43760 }
43761
43762
43763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43764   int jresult ;
43765   int result;
43766
43767   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43768   jresult = (int)result;
43769   return jresult;
43770 }
43771
43772
43773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43774   int jresult ;
43775   int result;
43776
43777   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43778   jresult = (int)result;
43779   return jresult;
43780 }
43781
43782
43783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43784   int jresult ;
43785   int result;
43786
43787   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43788   jresult = (int)result;
43789   return jresult;
43790 }
43791
43792
43793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43794   int jresult ;
43795   int result;
43796
43797   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43798   jresult = (int)result;
43799   return jresult;
43800 }
43801
43802
43803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43804   int jresult ;
43805   int result;
43806
43807   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43808   jresult = (int)result;
43809   return jresult;
43810 }
43811
43812
43813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43814   int jresult ;
43815   int result;
43816
43817   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43818   jresult = (int)result;
43819   return jresult;
43820 }
43821
43822
43823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43824   int jresult ;
43825   int result;
43826
43827   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43828   jresult = (int)result;
43829   return jresult;
43830 }
43831
43832
43833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43834   int jresult ;
43835   int result;
43836
43837   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43838   jresult = (int)result;
43839   return jresult;
43840 }
43841
43842
43843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43844   int jresult ;
43845   int result;
43846
43847   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43848   jresult = (int)result;
43849   return jresult;
43850 }
43851
43852
43853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43854   int jresult ;
43855   int result;
43856
43857   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43858   jresult = (int)result;
43859   return jresult;
43860 }
43861
43862
43863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43864   int jresult ;
43865   int result;
43866
43867   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43868   jresult = (int)result;
43869   return jresult;
43870 }
43871
43872
43873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43874   int jresult ;
43875   int result;
43876
43877   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43878   jresult = (int)result;
43879   return jresult;
43880 }
43881
43882
43883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43884   void * jresult ;
43885   Dali::CameraActor::Property *result = 0 ;
43886
43887   {
43888     try {
43889       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43890     } catch (std::out_of_range& e) {
43891       {
43892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43893       };
43894     } catch (std::exception& e) {
43895       {
43896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43897       };
43898     } catch (...) {
43899       {
43900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43901       };
43902     }
43903   }
43904   jresult = (void *)result;
43905   return jresult;
43906 }
43907
43908
43909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43910   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43911
43912   arg1 = (Dali::CameraActor::Property *)jarg1;
43913   {
43914     try {
43915       delete arg1;
43916     } catch (std::out_of_range& e) {
43917       {
43918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43919       };
43920     } catch (std::exception& e) {
43921       {
43922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43923       };
43924     } catch (...) {
43925       {
43926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43927       };
43928     }
43929   }
43930 }
43931
43932
43933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43934   void * jresult ;
43935   Dali::CameraActor *result = 0 ;
43936
43937   {
43938     try {
43939       result = (Dali::CameraActor *)new Dali::CameraActor();
43940     } catch (std::out_of_range& e) {
43941       {
43942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (std::exception& e) {
43945       {
43946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43947       };
43948     } catch (...) {
43949       {
43950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43951       };
43952     }
43953   }
43954   jresult = (void *)result;
43955   return jresult;
43956 }
43957
43958
43959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43960   void * jresult ;
43961   Dali::CameraActor result;
43962
43963   {
43964     try {
43965       result = Dali::CameraActor::New();
43966     } catch (std::out_of_range& e) {
43967       {
43968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43969       };
43970     } catch (std::exception& e) {
43971       {
43972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43973       };
43974     } catch (...) {
43975       {
43976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43977       };
43978     }
43979   }
43980   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43981   return jresult;
43982 }
43983
43984
43985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43986   void * jresult ;
43987   Dali::Size *arg1 = 0 ;
43988   Dali::CameraActor result;
43989
43990   arg1 = (Dali::Size *)jarg1;
43991   if (!arg1) {
43992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43993     return 0;
43994   }
43995   {
43996     try {
43997       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43998     } catch (std::out_of_range& e) {
43999       {
44000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (std::exception& e) {
44003       {
44004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44005       };
44006     } catch (...) {
44007       {
44008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44009       };
44010     }
44011   }
44012   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44013   return jresult;
44014 }
44015
44016
44017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44018   void * jresult ;
44019   Dali::BaseHandle arg1 ;
44020   Dali::BaseHandle *argp1 ;
44021   Dali::CameraActor result;
44022
44023   argp1 = (Dali::BaseHandle *)jarg1;
44024   if (!argp1) {
44025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44026     return 0;
44027   }
44028   arg1 = *argp1;
44029   {
44030     try {
44031       result = Dali::CameraActor::DownCast(arg1);
44032     } catch (std::out_of_range& e) {
44033       {
44034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44035       };
44036     } catch (std::exception& e) {
44037       {
44038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44039       };
44040     } catch (...) {
44041       {
44042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44043       };
44044     }
44045   }
44046   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44047   return jresult;
44048 }
44049
44050
44051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44052   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44053
44054   arg1 = (Dali::CameraActor *)jarg1;
44055   {
44056     try {
44057       delete arg1;
44058     } catch (std::out_of_range& e) {
44059       {
44060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44061       };
44062     } catch (std::exception& e) {
44063       {
44064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44065       };
44066     } catch (...) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44069       };
44070     }
44071   }
44072 }
44073
44074
44075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44076   void * jresult ;
44077   Dali::CameraActor *arg1 = 0 ;
44078   Dali::CameraActor *result = 0 ;
44079
44080   arg1 = (Dali::CameraActor *)jarg1;
44081   if (!arg1) {
44082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44083     return 0;
44084   }
44085   {
44086     try {
44087       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44088     } catch (std::out_of_range& e) {
44089       {
44090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44091       };
44092     } catch (std::exception& e) {
44093       {
44094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44095       };
44096     } catch (...) {
44097       {
44098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44099       };
44100     }
44101   }
44102   jresult = (void *)result;
44103   return jresult;
44104 }
44105
44106
44107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44108   void * jresult ;
44109   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44110   Dali::CameraActor *arg2 = 0 ;
44111   Dali::CameraActor *result = 0 ;
44112
44113   arg1 = (Dali::CameraActor *)jarg1;
44114   arg2 = (Dali::CameraActor *)jarg2;
44115   if (!arg2) {
44116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44117     return 0;
44118   }
44119   {
44120     try {
44121       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44122     } catch (std::out_of_range& e) {
44123       {
44124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44125       };
44126     } catch (std::exception& e) {
44127       {
44128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44129       };
44130     } catch (...) {
44131       {
44132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44133       };
44134     }
44135   }
44136   jresult = (void *)result;
44137   return jresult;
44138 }
44139
44140
44141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44142   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44143   Dali::Camera::Type arg2 ;
44144
44145   arg1 = (Dali::CameraActor *)jarg1;
44146   arg2 = (Dali::Camera::Type)jarg2;
44147   {
44148     try {
44149       (arg1)->SetType(arg2);
44150     } catch (std::out_of_range& e) {
44151       {
44152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44153       };
44154     } catch (std::exception& e) {
44155       {
44156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44157       };
44158     } catch (...) {
44159       {
44160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44161       };
44162     }
44163   }
44164 }
44165
44166
44167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44168   int jresult ;
44169   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44170   Dali::Camera::Type result;
44171
44172   arg1 = (Dali::CameraActor *)jarg1;
44173   {
44174     try {
44175       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44176     } catch (std::out_of_range& e) {
44177       {
44178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (std::exception& e) {
44181       {
44182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44183       };
44184     } catch (...) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44187       };
44188     }
44189   }
44190   jresult = (int)result;
44191   return jresult;
44192 }
44193
44194
44195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44196   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44197   Dali::Camera::ProjectionMode arg2 ;
44198
44199   arg1 = (Dali::CameraActor *)jarg1;
44200   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44201   {
44202     try {
44203       (arg1)->SetProjectionMode(arg2);
44204     } catch (std::out_of_range& e) {
44205       {
44206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44207       };
44208     } catch (std::exception& e) {
44209       {
44210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44211       };
44212     } catch (...) {
44213       {
44214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44215       };
44216     }
44217   }
44218 }
44219
44220
44221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44222   int jresult ;
44223   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44224   Dali::Camera::ProjectionMode result;
44225
44226   arg1 = (Dali::CameraActor *)jarg1;
44227   {
44228     try {
44229       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44230     } catch (std::out_of_range& e) {
44231       {
44232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44233       };
44234     } catch (std::exception& e) {
44235       {
44236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44237       };
44238     } catch (...) {
44239       {
44240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44241       };
44242     }
44243   }
44244   jresult = (int)result;
44245   return jresult;
44246 }
44247
44248
44249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44251   float arg2 ;
44252
44253   arg1 = (Dali::CameraActor *)jarg1;
44254   arg2 = (float)jarg2;
44255   {
44256     try {
44257       (arg1)->SetFieldOfView(arg2);
44258     } catch (std::out_of_range& e) {
44259       {
44260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44261       };
44262     } catch (std::exception& e) {
44263       {
44264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44265       };
44266     } catch (...) {
44267       {
44268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44269       };
44270     }
44271   }
44272 }
44273
44274
44275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44276   float jresult ;
44277   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44278   float result;
44279
44280   arg1 = (Dali::CameraActor *)jarg1;
44281   {
44282     try {
44283       result = (float)(arg1)->GetFieldOfView();
44284     } catch (std::out_of_range& e) {
44285       {
44286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44287       };
44288     } catch (std::exception& e) {
44289       {
44290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44291       };
44292     } catch (...) {
44293       {
44294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44295       };
44296     }
44297   }
44298   jresult = result;
44299   return jresult;
44300 }
44301
44302
44303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44305   float arg2 ;
44306
44307   arg1 = (Dali::CameraActor *)jarg1;
44308   arg2 = (float)jarg2;
44309   {
44310     try {
44311       (arg1)->SetAspectRatio(arg2);
44312     } catch (std::out_of_range& e) {
44313       {
44314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44315       };
44316     } catch (std::exception& e) {
44317       {
44318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44319       };
44320     } catch (...) {
44321       {
44322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44323       };
44324     }
44325   }
44326 }
44327
44328
44329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44330   float jresult ;
44331   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44332   float result;
44333
44334   arg1 = (Dali::CameraActor *)jarg1;
44335   {
44336     try {
44337       result = (float)(arg1)->GetAspectRatio();
44338     } catch (std::out_of_range& e) {
44339       {
44340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44341       };
44342     } catch (std::exception& e) {
44343       {
44344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44345       };
44346     } catch (...) {
44347       {
44348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44349       };
44350     }
44351   }
44352   jresult = result;
44353   return jresult;
44354 }
44355
44356
44357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44358   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44359   float arg2 ;
44360
44361   arg1 = (Dali::CameraActor *)jarg1;
44362   arg2 = (float)jarg2;
44363   {
44364     try {
44365       (arg1)->SetNearClippingPlane(arg2);
44366     } catch (std::out_of_range& e) {
44367       {
44368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44369       };
44370     } catch (std::exception& e) {
44371       {
44372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44373       };
44374     } catch (...) {
44375       {
44376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44377       };
44378     }
44379   }
44380 }
44381
44382
44383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44384   float jresult ;
44385   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44386   float result;
44387
44388   arg1 = (Dali::CameraActor *)jarg1;
44389   {
44390     try {
44391       result = (float)(arg1)->GetNearClippingPlane();
44392     } catch (std::out_of_range& e) {
44393       {
44394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (std::exception& e) {
44397       {
44398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44399       };
44400     } catch (...) {
44401       {
44402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44403       };
44404     }
44405   }
44406   jresult = result;
44407   return jresult;
44408 }
44409
44410
44411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44413   float arg2 ;
44414
44415   arg1 = (Dali::CameraActor *)jarg1;
44416   arg2 = (float)jarg2;
44417   {
44418     try {
44419       (arg1)->SetFarClippingPlane(arg2);
44420     } catch (std::out_of_range& e) {
44421       {
44422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44423       };
44424     } catch (std::exception& e) {
44425       {
44426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44427       };
44428     } catch (...) {
44429       {
44430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44431       };
44432     }
44433   }
44434 }
44435
44436
44437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44438   float jresult ;
44439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44440   float result;
44441
44442   arg1 = (Dali::CameraActor *)jarg1;
44443   {
44444     try {
44445       result = (float)(arg1)->GetFarClippingPlane();
44446     } catch (std::out_of_range& e) {
44447       {
44448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44449       };
44450     } catch (std::exception& e) {
44451       {
44452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44453       };
44454     } catch (...) {
44455       {
44456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44457       };
44458     }
44459   }
44460   jresult = result;
44461   return jresult;
44462 }
44463
44464
44465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44466   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44467   Dali::Vector3 *arg2 = 0 ;
44468
44469   arg1 = (Dali::CameraActor *)jarg1;
44470   arg2 = (Dali::Vector3 *)jarg2;
44471   if (!arg2) {
44472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44473     return ;
44474   }
44475   {
44476     try {
44477       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44478     } catch (std::out_of_range& e) {
44479       {
44480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (std::exception& e) {
44483       {
44484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44485       };
44486     } catch (...) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44489       };
44490     }
44491   }
44492 }
44493
44494
44495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44496   void * jresult ;
44497   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44498   Dali::Vector3 result;
44499
44500   arg1 = (Dali::CameraActor *)jarg1;
44501   {
44502     try {
44503       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44504     } catch (std::out_of_range& e) {
44505       {
44506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44507       };
44508     } catch (std::exception& e) {
44509       {
44510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44511       };
44512     } catch (...) {
44513       {
44514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44515       };
44516     }
44517   }
44518   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44519   return jresult;
44520 }
44521
44522
44523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44524   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44525   bool arg2 ;
44526
44527   arg1 = (Dali::CameraActor *)jarg1;
44528   arg2 = jarg2 ? true : false;
44529   {
44530     try {
44531       (arg1)->SetInvertYAxis(arg2);
44532     } catch (std::out_of_range& e) {
44533       {
44534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44535       };
44536     } catch (std::exception& e) {
44537       {
44538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44539       };
44540     } catch (...) {
44541       {
44542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44543       };
44544     }
44545   }
44546 }
44547
44548
44549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44550   unsigned int jresult ;
44551   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44552   bool result;
44553
44554   arg1 = (Dali::CameraActor *)jarg1;
44555   {
44556     try {
44557       result = (bool)(arg1)->GetInvertYAxis();
44558     } catch (std::out_of_range& e) {
44559       {
44560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44561       };
44562     } catch (std::exception& e) {
44563       {
44564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44565       };
44566     } catch (...) {
44567       {
44568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44569       };
44570     }
44571   }
44572   jresult = result;
44573   return jresult;
44574 }
44575
44576
44577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44578   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44579   Dali::Size *arg2 = 0 ;
44580
44581   arg1 = (Dali::CameraActor *)jarg1;
44582   arg2 = (Dali::Size *)jarg2;
44583   if (!arg2) {
44584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44585     return ;
44586   }
44587   {
44588     try {
44589       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44590     } catch (std::out_of_range& e) {
44591       {
44592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44593       };
44594     } catch (std::exception& e) {
44595       {
44596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44597       };
44598     } catch (...) {
44599       {
44600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44601       };
44602     }
44603   }
44604 }
44605
44606
44607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44608   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44609   Dali::Size *arg2 = 0 ;
44610
44611   arg1 = (Dali::CameraActor *)jarg1;
44612   arg2 = (Dali::Size *)jarg2;
44613   if (!arg2) {
44614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44615     return ;
44616   }
44617   {
44618     try {
44619       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44620     } catch (std::out_of_range& e) {
44621       {
44622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44623       };
44624     } catch (std::exception& e) {
44625       {
44626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44627       };
44628     } catch (...) {
44629       {
44630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44631       };
44632     }
44633   }
44634 }
44635
44636
44637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44638   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44639   float arg2 ;
44640   float arg3 ;
44641   float arg4 ;
44642   float arg5 ;
44643   float arg6 ;
44644   float arg7 ;
44645
44646   arg1 = (Dali::CameraActor *)jarg1;
44647   arg2 = (float)jarg2;
44648   arg3 = (float)jarg3;
44649   arg4 = (float)jarg4;
44650   arg5 = (float)jarg5;
44651   arg6 = (float)jarg6;
44652   arg7 = (float)jarg7;
44653   {
44654     try {
44655       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44656     } catch (std::out_of_range& e) {
44657       {
44658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44659       };
44660     } catch (std::exception& e) {
44661       {
44662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44663       };
44664     } catch (...) {
44665       {
44666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44667       };
44668     }
44669   }
44670 }
44671
44672
44673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44674   void * jresult ;
44675   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44676
44677   {
44678     try {
44679       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44680     } catch (std::out_of_range& e) {
44681       {
44682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44683       };
44684     } catch (std::exception& e) {
44685       {
44686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44687       };
44688     } catch (...) {
44689       {
44690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44691       };
44692     }
44693   }
44694   jresult = (void *)result;
44695   return jresult;
44696 }
44697
44698
44699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44700   void * jresult ;
44701   std::string arg1 ;
44702   Dali::Property::Value arg2 ;
44703   Dali::Property::Value *argp2 ;
44704   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44705
44706   if (!jarg1) {
44707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44708     return 0;
44709   }
44710   (&arg1)->assign(jarg1);
44711   argp2 = (Dali::Property::Value *)jarg2;
44712   if (!argp2) {
44713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44714     return 0;
44715   }
44716   arg2 = *argp2;
44717   {
44718     try {
44719       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44720     } catch (std::out_of_range& e) {
44721       {
44722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44723       };
44724     } catch (std::exception& e) {
44725       {
44726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44727       };
44728     } catch (...) {
44729       {
44730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44731       };
44732     }
44733   }
44734   jresult = (void *)result;
44735   return jresult;
44736 }
44737
44738
44739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44740   void * jresult ;
44741   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44742   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44743
44744   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44745   if (!arg1) {
44746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44747     return 0;
44748   }
44749   {
44750     try {
44751       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);
44752     } catch (std::out_of_range& e) {
44753       {
44754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44755       };
44756     } catch (std::exception& e) {
44757       {
44758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44759       };
44760     } catch (...) {
44761       {
44762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44763       };
44764     }
44765   }
44766   jresult = (void *)result;
44767   return jresult;
44768 }
44769
44770
44771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44772   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44773   std::string *arg2 = 0 ;
44774
44775   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44776   if (!jarg2) {
44777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44778     return ;
44779   }
44780   std::string arg2_str(jarg2);
44781   arg2 = &arg2_str;
44782   if (arg1) (arg1)->first = *arg2;
44783
44784   //argout typemap for const std::string&
44785
44786 }
44787
44788
44789 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44790   char * jresult ;
44791   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44792   std::string *result = 0 ;
44793
44794   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44795   result = (std::string *) & ((arg1)->first);
44796   jresult = SWIG_csharp_string_callback(result->c_str());
44797   return jresult;
44798 }
44799
44800
44801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44802   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44803   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44804
44805   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44806   arg2 = (Dali::Property::Value *)jarg2;
44807   if (arg1) (arg1)->second = *arg2;
44808 }
44809
44810
44811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44812   void * jresult ;
44813   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44814   Dali::Property::Value *result = 0 ;
44815
44816   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44817   result = (Dali::Property::Value *)& ((arg1)->second);
44818   jresult = (void *)result;
44819   return jresult;
44820 }
44821
44822
44823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44824   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44825
44826   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44827   {
44828     try {
44829       delete arg1;
44830     } catch (std::out_of_range& e) {
44831       {
44832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (std::exception& e) {
44835       {
44836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44837       };
44838     } catch (...) {
44839       {
44840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44841       };
44842     }
44843   }
44844 }
44845
44846
44847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44848   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44849
44850   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44851   {
44852     try {
44853       (arg1)->clear();
44854     } catch (std::out_of_range& e) {
44855       {
44856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44857       };
44858     } catch (std::exception& e) {
44859       {
44860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44861       };
44862     } catch (...) {
44863       {
44864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44865       };
44866     }
44867   }
44868 }
44869
44870
44871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44872   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44873   Dali::TouchPoint *arg2 = 0 ;
44874
44875   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44876   arg2 = (Dali::TouchPoint *)jarg2;
44877   if (!arg2) {
44878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44879     return ;
44880   }
44881   {
44882     try {
44883       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44884     } catch (std::out_of_range& e) {
44885       {
44886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44887       };
44888     } catch (std::exception& e) {
44889       {
44890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44891       };
44892     } catch (...) {
44893       {
44894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44895       };
44896     }
44897   }
44898 }
44899
44900
44901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44902   unsigned long jresult ;
44903   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44904   std::vector< Dali::TouchPoint >::size_type result;
44905
44906   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44907   {
44908     try {
44909       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44910     } catch (std::out_of_range& e) {
44911       {
44912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44913       };
44914     } catch (std::exception& e) {
44915       {
44916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44917       };
44918     } catch (...) {
44919       {
44920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44921       };
44922     }
44923   }
44924   jresult = (unsigned long)result;
44925   return jresult;
44926 }
44927
44928
44929 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44930   unsigned long jresult ;
44931   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44932   std::vector< Dali::TouchPoint >::size_type result;
44933
44934   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44935   {
44936     try {
44937       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44938     } catch (std::out_of_range& e) {
44939       {
44940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (std::exception& e) {
44943       {
44944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44945       };
44946     } catch (...) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44949       };
44950     }
44951   }
44952   jresult = (unsigned long)result;
44953   return jresult;
44954 }
44955
44956
44957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44958   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44959   std::vector< Dali::TouchPoint >::size_type arg2 ;
44960
44961   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44962   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44963   {
44964     try {
44965       (arg1)->reserve(arg2);
44966     } catch (std::out_of_range& e) {
44967       {
44968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44969       };
44970     } catch (std::exception& e) {
44971       {
44972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44973       };
44974     } catch (...) {
44975       {
44976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44977       };
44978     }
44979   }
44980 }
44981
44982
44983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44984   void * jresult ;
44985   std::vector< Dali::TouchPoint > *result = 0 ;
44986
44987   {
44988     try {
44989       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44990     } catch (std::out_of_range& e) {
44991       {
44992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44993       };
44994     } catch (std::exception& e) {
44995       {
44996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44997       };
44998     } catch (...) {
44999       {
45000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45001       };
45002     }
45003   }
45004   jresult = (void *)result;
45005   return jresult;
45006 }
45007
45008
45009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45010   void * jresult ;
45011   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45012   std::vector< Dali::TouchPoint > *result = 0 ;
45013
45014   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45015   if (!arg1) {
45016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45017     return 0;
45018   }
45019   {
45020     try {
45021       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45022     } catch (std::out_of_range& e) {
45023       {
45024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45025       };
45026     } catch (std::exception& e) {
45027       {
45028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45029       };
45030     } catch (...) {
45031       {
45032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45033       };
45034     }
45035   }
45036   jresult = (void *)result;
45037   return jresult;
45038 }
45039
45040
45041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45042   void * jresult ;
45043   int arg1 ;
45044   std::vector< Dali::TouchPoint > *result = 0 ;
45045
45046   arg1 = (int)jarg1;
45047   {
45048     try {
45049       try {
45050         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45051       }
45052       catch(std::out_of_range &_e) {
45053         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45054         return 0;
45055       }
45056
45057     } catch (std::out_of_range& e) {
45058       {
45059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (std::exception& e) {
45062       {
45063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45064       };
45065     } catch (...) {
45066       {
45067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45068       };
45069     }
45070   }
45071   jresult = (void *)result;
45072   return jresult;
45073 }
45074
45075
45076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45077   void * jresult ;
45078   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45079   int arg2 ;
45080   SwigValueWrapper< Dali::TouchPoint > result;
45081
45082   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45083   arg2 = (int)jarg2;
45084   {
45085     try {
45086       try {
45087         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45088       }
45089       catch(std::out_of_range &_e) {
45090         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45091         return 0;
45092       }
45093
45094     } catch (std::out_of_range& e) {
45095       {
45096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (std::exception& e) {
45099       {
45100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45101       };
45102     } catch (...) {
45103       {
45104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45105       };
45106     }
45107   }
45108   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45109   return jresult;
45110 }
45111
45112
45113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45114   void * jresult ;
45115   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45116   int arg2 ;
45117   Dali::TouchPoint *result = 0 ;
45118
45119   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45120   arg2 = (int)jarg2;
45121   {
45122     try {
45123       try {
45124         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45125       }
45126       catch(std::out_of_range &_e) {
45127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45128         return 0;
45129       }
45130
45131     } catch (std::out_of_range& e) {
45132       {
45133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (std::exception& e) {
45136       {
45137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45138       };
45139     } catch (...) {
45140       {
45141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45142       };
45143     }
45144   }
45145   jresult = (void *)result;
45146   return jresult;
45147 }
45148
45149
45150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45151   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45152   int arg2 ;
45153   Dali::TouchPoint *arg3 = 0 ;
45154
45155   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45156   arg2 = (int)jarg2;
45157   arg3 = (Dali::TouchPoint *)jarg3;
45158   if (!arg3) {
45159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45160     return ;
45161   }
45162   {
45163     try {
45164       try {
45165         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45166       }
45167       catch(std::out_of_range &_e) {
45168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45169         return ;
45170       }
45171
45172     } catch (std::out_of_range& e) {
45173       {
45174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45175       };
45176     } catch (std::exception& e) {
45177       {
45178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45179       };
45180     } catch (...) {
45181       {
45182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45183       };
45184     }
45185   }
45186 }
45187
45188
45189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45190   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45191   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45192
45193   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45194   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45195   if (!arg2) {
45196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45197     return ;
45198   }
45199   {
45200     try {
45201       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45202     } catch (std::out_of_range& e) {
45203       {
45204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45205       };
45206     } catch (std::exception& e) {
45207       {
45208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45209       };
45210     } catch (...) {
45211       {
45212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45213       };
45214     }
45215   }
45216 }
45217
45218
45219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45220   void * jresult ;
45221   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45222   int arg2 ;
45223   int arg3 ;
45224   std::vector< Dali::TouchPoint > *result = 0 ;
45225
45226   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45227   arg2 = (int)jarg2;
45228   arg3 = (int)jarg3;
45229   {
45230     try {
45231       try {
45232         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45233       }
45234       catch(std::out_of_range &_e) {
45235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45236         return 0;
45237       }
45238       catch(std::invalid_argument &_e) {
45239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45240         return 0;
45241       }
45242
45243     } catch (std::out_of_range& e) {
45244       {
45245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45246       };
45247     } catch (std::exception& e) {
45248       {
45249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45250       };
45251     } catch (...) {
45252       {
45253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45254       };
45255     }
45256   }
45257   jresult = (void *)result;
45258   return jresult;
45259 }
45260
45261
45262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45263   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45264   int arg2 ;
45265   Dali::TouchPoint *arg3 = 0 ;
45266
45267   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45268   arg2 = (int)jarg2;
45269   arg3 = (Dali::TouchPoint *)jarg3;
45270   if (!arg3) {
45271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45272     return ;
45273   }
45274   {
45275     try {
45276       try {
45277         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45278       }
45279       catch(std::out_of_range &_e) {
45280         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45281         return ;
45282       }
45283
45284     } catch (std::out_of_range& e) {
45285       {
45286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45287       };
45288     } catch (std::exception& e) {
45289       {
45290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45291       };
45292     } catch (...) {
45293       {
45294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45295       };
45296     }
45297   }
45298 }
45299
45300
45301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45302   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45303   int arg2 ;
45304   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45305
45306   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45307   arg2 = (int)jarg2;
45308   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45309   if (!arg3) {
45310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45311     return ;
45312   }
45313   {
45314     try {
45315       try {
45316         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45317       }
45318       catch(std::out_of_range &_e) {
45319         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45320         return ;
45321       }
45322
45323     } catch (std::out_of_range& e) {
45324       {
45325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45326       };
45327     } catch (std::exception& e) {
45328       {
45329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45330       };
45331     } catch (...) {
45332       {
45333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45334       };
45335     }
45336   }
45337 }
45338
45339
45340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45341   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45342   int arg2 ;
45343
45344   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45345   arg2 = (int)jarg2;
45346   {
45347     try {
45348       try {
45349         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45350       }
45351       catch(std::out_of_range &_e) {
45352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45353         return ;
45354       }
45355
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45363       };
45364     } catch (...) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45367       };
45368     }
45369   }
45370 }
45371
45372
45373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45374   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45375   int arg2 ;
45376   int arg3 ;
45377
45378   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45379   arg2 = (int)jarg2;
45380   arg3 = (int)jarg3;
45381   {
45382     try {
45383       try {
45384         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45385       }
45386       catch(std::out_of_range &_e) {
45387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45388         return ;
45389       }
45390       catch(std::invalid_argument &_e) {
45391         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45392         return ;
45393       }
45394
45395     } catch (std::out_of_range& e) {
45396       {
45397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45398       };
45399     } catch (std::exception& e) {
45400       {
45401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45402       };
45403     } catch (...) {
45404       {
45405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45406       };
45407     }
45408   }
45409 }
45410
45411
45412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45413   void * jresult ;
45414   Dali::TouchPoint *arg1 = 0 ;
45415   int arg2 ;
45416   std::vector< Dali::TouchPoint > *result = 0 ;
45417
45418   arg1 = (Dali::TouchPoint *)jarg1;
45419   if (!arg1) {
45420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45421     return 0;
45422   }
45423   arg2 = (int)jarg2;
45424   {
45425     try {
45426       try {
45427         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45428       }
45429       catch(std::out_of_range &_e) {
45430         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45431         return 0;
45432       }
45433
45434     } catch (std::out_of_range& e) {
45435       {
45436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (std::exception& e) {
45439       {
45440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (...) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45445       };
45446     }
45447   }
45448   jresult = (void *)result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45454   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45455
45456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45457   {
45458     try {
45459       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45460     } catch (std::out_of_range& e) {
45461       {
45462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45463       };
45464     } catch (std::exception& e) {
45465       {
45466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45467       };
45468     } catch (...) {
45469       {
45470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45471       };
45472     }
45473   }
45474 }
45475
45476
45477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45478   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45479   int arg2 ;
45480   int arg3 ;
45481
45482   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45483   arg2 = (int)jarg2;
45484   arg3 = (int)jarg3;
45485   {
45486     try {
45487       try {
45488         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45489       }
45490       catch(std::out_of_range &_e) {
45491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45492         return ;
45493       }
45494       catch(std::invalid_argument &_e) {
45495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45496         return ;
45497       }
45498
45499     } catch (std::out_of_range& e) {
45500       {
45501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45502       };
45503     } catch (std::exception& e) {
45504       {
45505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45506       };
45507     } catch (...) {
45508       {
45509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45510       };
45511     }
45512   }
45513 }
45514
45515
45516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45517   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45518   int arg2 ;
45519   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45520
45521   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45522   arg2 = (int)jarg2;
45523   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45524   if (!arg3) {
45525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45526     return ;
45527   }
45528   {
45529     try {
45530       try {
45531         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45532       }
45533       catch(std::out_of_range &_e) {
45534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45535         return ;
45536       }
45537
45538     } catch (std::out_of_range& e) {
45539       {
45540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (std::exception& e) {
45543       {
45544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45545       };
45546     } catch (...) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45549       };
45550     }
45551   }
45552 }
45553
45554
45555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45556   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45557
45558   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45559   {
45560     try {
45561       delete arg1;
45562     } catch (std::out_of_range& e) {
45563       {
45564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45565       };
45566     } catch (std::exception& e) {
45567       {
45568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45569       };
45570     } catch (...) {
45571       {
45572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45573       };
45574     }
45575   }
45576 }
45577
45578
45579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45580   void * jresult ;
45581   Dali::Rect< int > *result = 0 ;
45582
45583   {
45584     try {
45585       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45586     } catch (std::out_of_range& e) {
45587       {
45588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (std::exception& e) {
45591       {
45592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45593       };
45594     } catch (...) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45597       };
45598     }
45599   }
45600   jresult = (void *)result;
45601   return jresult;
45602 }
45603
45604
45605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45606   void * jresult ;
45607   int arg1 ;
45608   int arg2 ;
45609   int arg3 ;
45610   int arg4 ;
45611   Dali::Rect< int > *result = 0 ;
45612
45613   arg1 = (int)jarg1;
45614   arg2 = (int)jarg2;
45615   arg3 = (int)jarg3;
45616   arg4 = (int)jarg4;
45617   {
45618     try {
45619       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45620     } catch (std::out_of_range& e) {
45621       {
45622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45623       };
45624     } catch (std::exception& e) {
45625       {
45626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45627       };
45628     } catch (...) {
45629       {
45630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45631       };
45632     }
45633   }
45634   jresult = (void *)result;
45635   return jresult;
45636 }
45637
45638
45639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45640   void * jresult ;
45641   Dali::Rect< int > *arg1 = 0 ;
45642   Dali::Rect< int > *result = 0 ;
45643
45644   arg1 = (Dali::Rect< int > *)jarg1;
45645   if (!arg1) {
45646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45647     return 0;
45648   }
45649   {
45650     try {
45651       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45652     } catch (std::out_of_range& e) {
45653       {
45654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45655       };
45656     } catch (std::exception& e) {
45657       {
45658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45659       };
45660     } catch (...) {
45661       {
45662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45663       };
45664     }
45665   }
45666   jresult = (void *)result;
45667   return jresult;
45668 }
45669
45670
45671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45672   void * jresult ;
45673   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45674   Dali::Rect< int > *arg2 = 0 ;
45675   Dali::Rect< int > *result = 0 ;
45676
45677   arg1 = (Dali::Rect< int > *)jarg1;
45678   arg2 = (Dali::Rect< int > *)jarg2;
45679   if (!arg2) {
45680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45681     return 0;
45682   }
45683   {
45684     try {
45685       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45686     } catch (std::out_of_range& e) {
45687       {
45688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45689       };
45690     } catch (std::exception& e) {
45691       {
45692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45693       };
45694     } catch (...) {
45695       {
45696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45697       };
45698     }
45699   }
45700   jresult = (void *)result;
45701   return jresult;
45702 }
45703
45704
45705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45706   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45707   int arg2 ;
45708   int arg3 ;
45709   int arg4 ;
45710   int arg5 ;
45711
45712   arg1 = (Dali::Rect< int > *)jarg1;
45713   arg2 = (int)jarg2;
45714   arg3 = (int)jarg3;
45715   arg4 = (int)jarg4;
45716   arg5 = (int)jarg5;
45717   {
45718     try {
45719       (arg1)->Set(arg2,arg3,arg4,arg5);
45720     } catch (std::out_of_range& e) {
45721       {
45722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45723       };
45724     } catch (std::exception& e) {
45725       {
45726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45731       };
45732     }
45733   }
45734 }
45735
45736
45737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45738   unsigned int jresult ;
45739   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45740   bool result;
45741
45742   arg1 = (Dali::Rect< int > *)jarg1;
45743   {
45744     try {
45745       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45746     } catch (std::out_of_range& e) {
45747       {
45748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45749       };
45750     } catch (std::exception& e) {
45751       {
45752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45753       };
45754     } catch (...) {
45755       {
45756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45757       };
45758     }
45759   }
45760   jresult = result;
45761   return jresult;
45762 }
45763
45764
45765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45766   int jresult ;
45767   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45768   int result;
45769
45770   arg1 = (Dali::Rect< int > *)jarg1;
45771   {
45772     try {
45773       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45774     } catch (std::out_of_range& e) {
45775       {
45776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45777       };
45778     } catch (std::exception& e) {
45779       {
45780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45781       };
45782     } catch (...) {
45783       {
45784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45785       };
45786     }
45787   }
45788   jresult = result;
45789   return jresult;
45790 }
45791
45792
45793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45794   int jresult ;
45795   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45796   int result;
45797
45798   arg1 = (Dali::Rect< int > *)jarg1;
45799   {
45800     try {
45801       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45802     } catch (std::out_of_range& e) {
45803       {
45804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (std::exception& e) {
45807       {
45808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (...) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45813       };
45814     }
45815   }
45816   jresult = result;
45817   return jresult;
45818 }
45819
45820
45821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45822   int jresult ;
45823   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45824   int result;
45825
45826   arg1 = (Dali::Rect< int > *)jarg1;
45827   {
45828     try {
45829       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45830     } catch (std::out_of_range& e) {
45831       {
45832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (std::exception& e) {
45835       {
45836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (...) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45841       };
45842     }
45843   }
45844   jresult = result;
45845   return jresult;
45846 }
45847
45848
45849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45850   int jresult ;
45851   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45852   int result;
45853
45854   arg1 = (Dali::Rect< int > *)jarg1;
45855   {
45856     try {
45857       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45858     } catch (std::out_of_range& e) {
45859       {
45860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45861       };
45862     } catch (std::exception& e) {
45863       {
45864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45865       };
45866     } catch (...) {
45867       {
45868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45869       };
45870     }
45871   }
45872   jresult = result;
45873   return jresult;
45874 }
45875
45876
45877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45878   int jresult ;
45879   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45880   int result;
45881
45882   arg1 = (Dali::Rect< int > *)jarg1;
45883   {
45884     try {
45885       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45886     } catch (std::out_of_range& e) {
45887       {
45888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (std::exception& e) {
45891       {
45892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45893       };
45894     } catch (...) {
45895       {
45896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45897       };
45898     }
45899   }
45900   jresult = result;
45901   return jresult;
45902 }
45903
45904
45905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45906   unsigned int jresult ;
45907   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45908   Dali::Rect< int > *arg2 = 0 ;
45909   bool result;
45910
45911   arg1 = (Dali::Rect< int > *)jarg1;
45912   arg2 = (Dali::Rect< int > *)jarg2;
45913   if (!arg2) {
45914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45915     return 0;
45916   }
45917   {
45918     try {
45919       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45920     } catch (std::out_of_range& e) {
45921       {
45922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45923       };
45924     } catch (std::exception& e) {
45925       {
45926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45927       };
45928     } catch (...) {
45929       {
45930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45931       };
45932     }
45933   }
45934   jresult = result;
45935   return jresult;
45936 }
45937
45938
45939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45940   unsigned int jresult ;
45941   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45942   Dali::Rect< int > *arg2 = 0 ;
45943   bool result;
45944
45945   arg1 = (Dali::Rect< int > *)jarg1;
45946   arg2 = (Dali::Rect< int > *)jarg2;
45947   if (!arg2) {
45948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45949     return 0;
45950   }
45951   {
45952     try {
45953       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45954     } catch (std::out_of_range& e) {
45955       {
45956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (std::exception& e) {
45959       {
45960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45961       };
45962     } catch (...) {
45963       {
45964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45965       };
45966     }
45967   }
45968   jresult = result;
45969   return jresult;
45970 }
45971
45972
45973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45974   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45975   int arg2 ;
45976
45977   arg1 = (Dali::Rect< int > *)jarg1;
45978   arg2 = (int)jarg2;
45979   if (arg1) (arg1)->x = arg2;
45980 }
45981
45982
45983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45984   int jresult ;
45985   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45986   int result;
45987
45988   arg1 = (Dali::Rect< int > *)jarg1;
45989   result = (int) ((arg1)->x);
45990   jresult = result;
45991   return jresult;
45992 }
45993
45994
45995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45996   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45997   int arg2 ;
45998
45999   arg1 = (Dali::Rect< int > *)jarg1;
46000   arg2 = (int)jarg2;
46001   if (arg1) (arg1)->left = arg2;
46002 }
46003
46004
46005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46006   int jresult ;
46007   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46008   int result;
46009
46010   arg1 = (Dali::Rect< int > *)jarg1;
46011   result = (int) ((arg1)->left);
46012   jresult = result;
46013   return jresult;
46014 }
46015
46016
46017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46018   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46019   int arg2 ;
46020
46021   arg1 = (Dali::Rect< int > *)jarg1;
46022   arg2 = (int)jarg2;
46023   if (arg1) (arg1)->y = arg2;
46024 }
46025
46026
46027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46028   int jresult ;
46029   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46030   int result;
46031
46032   arg1 = (Dali::Rect< int > *)jarg1;
46033   result = (int) ((arg1)->y);
46034   jresult = result;
46035   return jresult;
46036 }
46037
46038
46039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46040   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46041   int arg2 ;
46042
46043   arg1 = (Dali::Rect< int > *)jarg1;
46044   arg2 = (int)jarg2;
46045   if (arg1) (arg1)->right = arg2;
46046 }
46047
46048
46049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46050   int jresult ;
46051   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46052   int result;
46053
46054   arg1 = (Dali::Rect< int > *)jarg1;
46055   result = (int) ((arg1)->right);
46056   jresult = result;
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46062   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46063   int arg2 ;
46064
46065   arg1 = (Dali::Rect< int > *)jarg1;
46066   arg2 = (int)jarg2;
46067   if (arg1) (arg1)->width = arg2;
46068 }
46069
46070
46071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46072   int jresult ;
46073   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46074   int result;
46075
46076   arg1 = (Dali::Rect< int > *)jarg1;
46077   result = (int) ((arg1)->width);
46078   jresult = result;
46079   return jresult;
46080 }
46081
46082
46083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46084   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46085   int arg2 ;
46086
46087   arg1 = (Dali::Rect< int > *)jarg1;
46088   arg2 = (int)jarg2;
46089   if (arg1) (arg1)->bottom = arg2;
46090 }
46091
46092
46093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46094   int jresult ;
46095   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46096   int result;
46097
46098   arg1 = (Dali::Rect< int > *)jarg1;
46099   result = (int) ((arg1)->bottom);
46100   jresult = result;
46101   return jresult;
46102 }
46103
46104
46105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46106   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46107   int arg2 ;
46108
46109   arg1 = (Dali::Rect< int > *)jarg1;
46110   arg2 = (int)jarg2;
46111   if (arg1) (arg1)->height = arg2;
46112 }
46113
46114
46115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46116   int jresult ;
46117   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46118   int result;
46119
46120   arg1 = (Dali::Rect< int > *)jarg1;
46121   result = (int) ((arg1)->height);
46122   jresult = result;
46123   return jresult;
46124 }
46125
46126
46127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46128   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46129   int arg2 ;
46130
46131   arg1 = (Dali::Rect< int > *)jarg1;
46132   arg2 = (int)jarg2;
46133   if (arg1) (arg1)->top = arg2;
46134 }
46135
46136
46137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46138   int jresult ;
46139   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46140   int result;
46141
46142   arg1 = (Dali::Rect< int > *)jarg1;
46143   result = (int) ((arg1)->top);
46144   jresult = result;
46145   return jresult;
46146 }
46147
46148
46149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46150   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46151
46152   arg1 = (Dali::Rect< int > *)jarg1;
46153   {
46154     try {
46155       delete arg1;
46156     } catch (std::out_of_range& e) {
46157       {
46158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46159       };
46160     } catch (std::exception& e) {
46161       {
46162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46167       };
46168     }
46169   }
46170 }
46171
46172
46173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46174   void * jresult ;
46175   Dali::Rect< float > *result = 0 ;
46176
46177   {
46178     try {
46179       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46180     } catch (std::out_of_range& e) {
46181       {
46182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46183       };
46184     } catch (std::exception& e) {
46185       {
46186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46187       };
46188     } catch (...) {
46189       {
46190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46191       };
46192     }
46193   }
46194   jresult = (void *)result;
46195   return jresult;
46196 }
46197
46198
46199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46200   void * jresult ;
46201   float arg1 ;
46202   float arg2 ;
46203   float arg3 ;
46204   float arg4 ;
46205   Dali::Rect< float > *result = 0 ;
46206
46207   arg1 = (float)jarg1;
46208   arg2 = (float)jarg2;
46209   arg3 = (float)jarg3;
46210   arg4 = (float)jarg4;
46211   {
46212     try {
46213       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46214     } catch (std::out_of_range& e) {
46215       {
46216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46217       };
46218     } catch (std::exception& e) {
46219       {
46220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46221       };
46222     } catch (...) {
46223       {
46224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46225       };
46226     }
46227   }
46228   jresult = (void *)result;
46229   return jresult;
46230 }
46231
46232
46233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46234   void * jresult ;
46235   Dali::Rect< float > *arg1 = 0 ;
46236   Dali::Rect< float > *result = 0 ;
46237
46238   arg1 = (Dali::Rect< float > *)jarg1;
46239   if (!arg1) {
46240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46241     return 0;
46242   }
46243   {
46244     try {
46245       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46246     } catch (std::out_of_range& e) {
46247       {
46248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46249       };
46250     } catch (std::exception& e) {
46251       {
46252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46253       };
46254     } catch (...) {
46255       {
46256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46257       };
46258     }
46259   }
46260   jresult = (void *)result;
46261   return jresult;
46262 }
46263
46264
46265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46266   void * jresult ;
46267   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46268   Dali::Rect< float > *arg2 = 0 ;
46269   Dali::Rect< float > *result = 0 ;
46270
46271   arg1 = (Dali::Rect< float > *)jarg1;
46272   arg2 = (Dali::Rect< float > *)jarg2;
46273   if (!arg2) {
46274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46275     return 0;
46276   }
46277   {
46278     try {
46279       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46280     } catch (std::out_of_range& e) {
46281       {
46282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46283       };
46284     } catch (std::exception& e) {
46285       {
46286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46287       };
46288     } catch (...) {
46289       {
46290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46291       };
46292     }
46293   }
46294   jresult = (void *)result;
46295   return jresult;
46296 }
46297
46298
46299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46300   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46301   float arg2 ;
46302   float arg3 ;
46303   float arg4 ;
46304   float arg5 ;
46305
46306   arg1 = (Dali::Rect< float > *)jarg1;
46307   arg2 = (float)jarg2;
46308   arg3 = (float)jarg3;
46309   arg4 = (float)jarg4;
46310   arg5 = (float)jarg5;
46311   {
46312     try {
46313       (arg1)->Set(arg2,arg3,arg4,arg5);
46314     } catch (std::out_of_range& e) {
46315       {
46316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46317       };
46318     } catch (std::exception& e) {
46319       {
46320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46321       };
46322     } catch (...) {
46323       {
46324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46325       };
46326     }
46327   }
46328 }
46329
46330
46331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46332   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46333   float arg2 ;
46334
46335   arg1 = (Dali::Rect< float > *)jarg1;
46336   arg2 = (float)jarg2;
46337   if (arg1) (arg1)->x = arg2;
46338 }
46339
46340
46341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46342   float jresult ;
46343   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46344   float result;
46345
46346   arg1 = (Dali::Rect< float > *)jarg1;
46347   result = (float) ((arg1)->x);
46348   jresult = result;
46349   return jresult;
46350 }
46351
46352
46353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46354   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46355   float arg2 ;
46356
46357   arg1 = (Dali::Rect< float > *)jarg1;
46358   arg2 = (float)jarg2;
46359   if (arg1) (arg1)->left = arg2;
46360 }
46361
46362
46363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46364   float jresult ;
46365   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46366   float result;
46367
46368   arg1 = (Dali::Rect< float > *)jarg1;
46369   result = (float) ((arg1)->left);
46370   jresult = result;
46371   return jresult;
46372 }
46373
46374
46375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46376   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46377   float arg2 ;
46378
46379   arg1 = (Dali::Rect< float > *)jarg1;
46380   arg2 = (float)jarg2;
46381   if (arg1) (arg1)->y = arg2;
46382 }
46383
46384
46385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46386   float jresult ;
46387   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46388   float result;
46389
46390   arg1 = (Dali::Rect< float > *)jarg1;
46391   result = (float) ((arg1)->y);
46392   jresult = result;
46393   return jresult;
46394 }
46395
46396
46397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46398   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46399   float arg2 ;
46400
46401   arg1 = (Dali::Rect< float > *)jarg1;
46402   arg2 = (float)jarg2;
46403   if (arg1) (arg1)->right = arg2;
46404 }
46405
46406
46407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46408   float jresult ;
46409   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46410   float result;
46411
46412   arg1 = (Dali::Rect< float > *)jarg1;
46413   result = (float) ((arg1)->right);
46414   jresult = result;
46415   return jresult;
46416 }
46417
46418
46419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46420   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46421   float arg2 ;
46422
46423   arg1 = (Dali::Rect< float > *)jarg1;
46424   arg2 = (float)jarg2;
46425   if (arg1) (arg1)->width = arg2;
46426 }
46427
46428
46429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46430   float jresult ;
46431   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46432   float result;
46433
46434   arg1 = (Dali::Rect< float > *)jarg1;
46435   result = (float) ((arg1)->width);
46436   jresult = result;
46437   return jresult;
46438 }
46439
46440
46441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46442   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46443   float arg2 ;
46444
46445   arg1 = (Dali::Rect< float > *)jarg1;
46446   arg2 = (float)jarg2;
46447   if (arg1) (arg1)->bottom = arg2;
46448 }
46449
46450
46451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46452   float jresult ;
46453   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46454   float result;
46455
46456   arg1 = (Dali::Rect< float > *)jarg1;
46457   result = (float) ((arg1)->bottom);
46458   jresult = result;
46459   return jresult;
46460 }
46461
46462
46463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46464   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46465   float arg2 ;
46466
46467   arg1 = (Dali::Rect< float > *)jarg1;
46468   arg2 = (float)jarg2;
46469   if (arg1) (arg1)->height = arg2;
46470 }
46471
46472
46473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46474   float jresult ;
46475   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46476   float result;
46477
46478   arg1 = (Dali::Rect< float > *)jarg1;
46479   result = (float) ((arg1)->height);
46480   jresult = result;
46481   return jresult;
46482 }
46483
46484
46485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46486   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46487   float arg2 ;
46488
46489   arg1 = (Dali::Rect< float > *)jarg1;
46490   arg2 = (float)jarg2;
46491   if (arg1) (arg1)->top = arg2;
46492 }
46493
46494
46495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46496   float jresult ;
46497   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46498   float result;
46499
46500   arg1 = (Dali::Rect< float > *)jarg1;
46501   result = (float) ((arg1)->top);
46502   jresult = result;
46503   return jresult;
46504 }
46505
46506
46507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46508   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46509
46510   arg1 = (Dali::Rect< float > *)jarg1;
46511   {
46512     try {
46513       delete arg1;
46514     } catch (std::out_of_range& e) {
46515       {
46516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46517       };
46518     } catch (std::exception& e) {
46519       {
46520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46521       };
46522     } catch (...) {
46523       {
46524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46525       };
46526     }
46527   }
46528 }
46529
46530
46531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46532   int jresult ;
46533   int result;
46534
46535   result = (int)Dali::Vector< int >::BaseType;
46536   jresult = (int)result;
46537   return jresult;
46538 }
46539
46540
46541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46542   void * jresult ;
46543   Dali::Vector< int > *result = 0 ;
46544
46545   {
46546     try {
46547       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46548     } catch (std::out_of_range& e) {
46549       {
46550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (std::exception& e) {
46553       {
46554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46555       };
46556     } catch (...) {
46557       {
46558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46559       };
46560     }
46561   }
46562   jresult = (void *)result;
46563   return jresult;
46564 }
46565
46566
46567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46568   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46569
46570   arg1 = (Dali::Vector< int > *)jarg1;
46571   {
46572     try {
46573       delete arg1;
46574     } catch (std::out_of_range& e) {
46575       {
46576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (std::exception& e) {
46579       {
46580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46585       };
46586     }
46587   }
46588 }
46589
46590
46591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46592   void * jresult ;
46593   Dali::Vector< int > *arg1 = 0 ;
46594   Dali::Vector< int > *result = 0 ;
46595
46596   arg1 = (Dali::Vector< int > *)jarg1;
46597   if (!arg1) {
46598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46599     return 0;
46600   }
46601   {
46602     try {
46603       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46604     } catch (std::out_of_range& e) {
46605       {
46606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (std::exception& e) {
46609       {
46610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46611       };
46612     } catch (...) {
46613       {
46614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46615       };
46616     }
46617   }
46618   jresult = (void *)result;
46619   return jresult;
46620 }
46621
46622
46623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46624   void * jresult ;
46625   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46626   Dali::Vector< int > *arg2 = 0 ;
46627   Dali::Vector< int > *result = 0 ;
46628
46629   arg1 = (Dali::Vector< int > *)jarg1;
46630   arg2 = (Dali::Vector< int > *)jarg2;
46631   if (!arg2) {
46632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46633     return 0;
46634   }
46635   {
46636     try {
46637       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46638     } catch (std::out_of_range& e) {
46639       {
46640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46641       };
46642     } catch (std::exception& e) {
46643       {
46644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46645       };
46646     } catch (...) {
46647       {
46648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46649       };
46650     }
46651   }
46652   jresult = (void *)result;
46653   return jresult;
46654 }
46655
46656
46657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46658   void * jresult ;
46659   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46660   Dali::Vector< int >::Iterator result;
46661
46662   arg1 = (Dali::Vector< int > *)jarg1;
46663   {
46664     try {
46665       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46666     } catch (std::out_of_range& e) {
46667       {
46668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46669       };
46670     } catch (std::exception& e) {
46671       {
46672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46673       };
46674     } catch (...) {
46675       {
46676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46677       };
46678     }
46679   }
46680   jresult = (void *)result;
46681   return jresult;
46682 }
46683
46684
46685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46686   void * jresult ;
46687   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46688   Dali::Vector< int >::Iterator result;
46689
46690   arg1 = (Dali::Vector< int > *)jarg1;
46691   {
46692     try {
46693       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46694     } catch (std::out_of_range& e) {
46695       {
46696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46697       };
46698     } catch (std::exception& e) {
46699       {
46700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46701       };
46702     } catch (...) {
46703       {
46704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46705       };
46706     }
46707   }
46708   jresult = (void *)result;
46709   return jresult;
46710 }
46711
46712
46713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46714   void * jresult ;
46715   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46716   Dali::Vector< int >::SizeType arg2 ;
46717   Dali::Vector< int >::ItemType *result = 0 ;
46718
46719   arg1 = (Dali::Vector< int > *)jarg1;
46720   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46721   {
46722     try {
46723       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46724     } catch (std::out_of_range& e) {
46725       {
46726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46727       };
46728     } catch (std::exception& e) {
46729       {
46730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46731       };
46732     } catch (...) {
46733       {
46734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46735       };
46736     }
46737   }
46738   jresult = (void *)result;
46739   return jresult;
46740 }
46741
46742
46743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46744   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46745   Dali::Vector< int >::ItemType *arg2 = 0 ;
46746   Dali::Vector< int >::ItemType temp2 ;
46747
46748   arg1 = (Dali::Vector< int > *)jarg1;
46749   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46750   arg2 = &temp2;
46751   {
46752     try {
46753       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46754     } catch (std::out_of_range& e) {
46755       {
46756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46757       };
46758     } catch (std::exception& e) {
46759       {
46760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46761       };
46762     } catch (...) {
46763       {
46764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46765       };
46766     }
46767   }
46768 }
46769
46770
46771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46772   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46773   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46774   Dali::Vector< int >::ItemType *arg3 = 0 ;
46775   Dali::Vector< int >::ItemType temp3 ;
46776
46777   arg1 = (Dali::Vector< int > *)jarg1;
46778   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46779   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46780   arg3 = &temp3;
46781   {
46782     try {
46783       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46784     } catch (std::out_of_range& e) {
46785       {
46786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46787       };
46788     } catch (std::exception& e) {
46789       {
46790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46791       };
46792     } catch (...) {
46793       {
46794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46795       };
46796     }
46797   }
46798 }
46799
46800
46801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46802   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46803   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46804   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46805   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46806
46807   arg1 = (Dali::Vector< int > *)jarg1;
46808   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46809   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46810   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46811   {
46812     try {
46813       (arg1)->Insert(arg2,arg3,arg4);
46814     } catch (std::out_of_range& e) {
46815       {
46816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46817       };
46818     } catch (std::exception& e) {
46819       {
46820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46821       };
46822     } catch (...) {
46823       {
46824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46825       };
46826     }
46827   }
46828 }
46829
46830
46831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46832   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46833   Dali::Vector< int >::SizeType arg2 ;
46834
46835   arg1 = (Dali::Vector< int > *)jarg1;
46836   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46837   {
46838     try {
46839       (arg1)->Reserve(arg2);
46840     } catch (std::out_of_range& e) {
46841       {
46842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46843       };
46844     } catch (std::exception& e) {
46845       {
46846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46847       };
46848     } catch (...) {
46849       {
46850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46851       };
46852     }
46853   }
46854 }
46855
46856
46857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46858   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46859   Dali::Vector< int >::SizeType arg2 ;
46860
46861   arg1 = (Dali::Vector< int > *)jarg1;
46862   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46863   {
46864     try {
46865       (arg1)->Resize(arg2);
46866     } catch (std::out_of_range& e) {
46867       {
46868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (std::exception& e) {
46871       {
46872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46873       };
46874     } catch (...) {
46875       {
46876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46877       };
46878     }
46879   }
46880 }
46881
46882
46883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46884   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46885   Dali::Vector< int >::SizeType arg2 ;
46886   Dali::Vector< int >::ItemType *arg3 = 0 ;
46887   Dali::Vector< int >::ItemType temp3 ;
46888
46889   arg1 = (Dali::Vector< int > *)jarg1;
46890   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46891   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46892   arg3 = &temp3;
46893   {
46894     try {
46895       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46896     } catch (std::out_of_range& e) {
46897       {
46898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46899       };
46900     } catch (std::exception& e) {
46901       {
46902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46903       };
46904     } catch (...) {
46905       {
46906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46907       };
46908     }
46909   }
46910 }
46911
46912
46913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46914   void * jresult ;
46915   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46916   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46917   Dali::Vector< int >::Iterator result;
46918
46919   arg1 = (Dali::Vector< int > *)jarg1;
46920   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46921   {
46922     try {
46923       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46924     } catch (std::out_of_range& e) {
46925       {
46926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46927       };
46928     } catch (std::exception& e) {
46929       {
46930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46931       };
46932     } catch (...) {
46933       {
46934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46935       };
46936     }
46937   }
46938   jresult = (void *)result;
46939   return jresult;
46940 }
46941
46942
46943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46944   void * jresult ;
46945   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46946   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46947   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46948   Dali::Vector< int >::Iterator result;
46949
46950   arg1 = (Dali::Vector< int > *)jarg1;
46951   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46952   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46953   {
46954     try {
46955       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46956     } catch (std::out_of_range& e) {
46957       {
46958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46959       };
46960     } catch (std::exception& e) {
46961       {
46962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46963       };
46964     } catch (...) {
46965       {
46966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46967       };
46968     }
46969   }
46970   jresult = (void *)result;
46971   return jresult;
46972 }
46973
46974
46975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46976   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46977   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46978
46979   arg1 = (Dali::Vector< int > *)jarg1;
46980   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46981   {
46982     try {
46983       (arg1)->Remove(arg2);
46984     } catch (std::out_of_range& e) {
46985       {
46986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46987       };
46988     } catch (std::exception& e) {
46989       {
46990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46991       };
46992     } catch (...) {
46993       {
46994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46995       };
46996     }
46997   }
46998 }
46999
47000
47001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
47002   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47003   Dali::Vector< int > *arg2 = 0 ;
47004
47005   arg1 = (Dali::Vector< int > *)jarg1;
47006   arg2 = (Dali::Vector< int > *)jarg2;
47007   if (!arg2) {
47008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47009     return ;
47010   }
47011   {
47012     try {
47013       (arg1)->Swap(*arg2);
47014     } catch (std::out_of_range& e) {
47015       {
47016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47017       };
47018     } catch (std::exception& e) {
47019       {
47020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47021       };
47022     } catch (...) {
47023       {
47024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47025       };
47026     }
47027   }
47028 }
47029
47030
47031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47032   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47033
47034   arg1 = (Dali::Vector< int > *)jarg1;
47035   {
47036     try {
47037       (arg1)->Clear();
47038     } catch (std::out_of_range& e) {
47039       {
47040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (std::exception& e) {
47043       {
47044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47045       };
47046     } catch (...) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47049       };
47050     }
47051   }
47052 }
47053
47054
47055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47056   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47057
47058   arg1 = (Dali::Vector< int > *)jarg1;
47059   {
47060     try {
47061       (arg1)->Release();
47062     } catch (std::out_of_range& e) {
47063       {
47064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47065       };
47066     } catch (std::exception& e) {
47067       {
47068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47069       };
47070     } catch (...) {
47071       {
47072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47073       };
47074     }
47075   }
47076 }
47077
47078
47079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47080   int jresult ;
47081   int result;
47082
47083   result = (int)Dali::Vector< float >::BaseType;
47084   jresult = (int)result;
47085   return jresult;
47086 }
47087
47088
47089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47090   void * jresult ;
47091   Dali::Vector< float > *result = 0 ;
47092
47093   {
47094     try {
47095       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47096     } catch (std::out_of_range& e) {
47097       {
47098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47099       };
47100     } catch (std::exception& e) {
47101       {
47102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47103       };
47104     } catch (...) {
47105       {
47106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47107       };
47108     }
47109   }
47110   jresult = (void *)result;
47111   return jresult;
47112 }
47113
47114
47115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47116   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47117
47118   arg1 = (Dali::Vector< float > *)jarg1;
47119   {
47120     try {
47121       delete arg1;
47122     } catch (std::out_of_range& e) {
47123       {
47124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47125       };
47126     } catch (std::exception& e) {
47127       {
47128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47129       };
47130     } catch (...) {
47131       {
47132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47133       };
47134     }
47135   }
47136 }
47137
47138
47139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47140   void * jresult ;
47141   Dali::Vector< float > *arg1 = 0 ;
47142   Dali::Vector< float > *result = 0 ;
47143
47144   arg1 = (Dali::Vector< float > *)jarg1;
47145   if (!arg1) {
47146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47147     return 0;
47148   }
47149   {
47150     try {
47151       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47152     } catch (std::out_of_range& e) {
47153       {
47154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47155       };
47156     } catch (std::exception& e) {
47157       {
47158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47159       };
47160     } catch (...) {
47161       {
47162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47163       };
47164     }
47165   }
47166   jresult = (void *)result;
47167   return jresult;
47168 }
47169
47170
47171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47172   void * jresult ;
47173   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47174   Dali::Vector< float > *arg2 = 0 ;
47175   Dali::Vector< float > *result = 0 ;
47176
47177   arg1 = (Dali::Vector< float > *)jarg1;
47178   arg2 = (Dali::Vector< float > *)jarg2;
47179   if (!arg2) {
47180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47181     return 0;
47182   }
47183   {
47184     try {
47185       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47186     } catch (std::out_of_range& e) {
47187       {
47188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (std::exception& e) {
47191       {
47192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47193       };
47194     } catch (...) {
47195       {
47196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47197       };
47198     }
47199   }
47200   jresult = (void *)result;
47201   return jresult;
47202 }
47203
47204
47205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47206   void * jresult ;
47207   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47208   Dali::Vector< float >::Iterator result;
47209
47210   arg1 = (Dali::Vector< float > *)jarg1;
47211   {
47212     try {
47213       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47214     } catch (std::out_of_range& e) {
47215       {
47216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (std::exception& e) {
47219       {
47220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47221       };
47222     } catch (...) {
47223       {
47224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47225       };
47226     }
47227   }
47228   jresult = (void *)result;
47229   return jresult;
47230 }
47231
47232
47233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47234   void * jresult ;
47235   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47236   Dali::Vector< float >::Iterator result;
47237
47238   arg1 = (Dali::Vector< float > *)jarg1;
47239   {
47240     try {
47241       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47242     } catch (std::out_of_range& e) {
47243       {
47244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (std::exception& e) {
47247       {
47248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (...) {
47251       {
47252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47253       };
47254     }
47255   }
47256   jresult = (void *)result;
47257   return jresult;
47258 }
47259
47260
47261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47262   void * jresult ;
47263   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47264   Dali::Vector< float >::SizeType arg2 ;
47265   Dali::Vector< float >::ItemType *result = 0 ;
47266
47267   arg1 = (Dali::Vector< float > *)jarg1;
47268   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47269   {
47270     try {
47271       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47272     } catch (std::out_of_range& e) {
47273       {
47274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47275       };
47276     } catch (std::exception& e) {
47277       {
47278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47279       };
47280     } catch (...) {
47281       {
47282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47283       };
47284     }
47285   }
47286   jresult = (void *)result;
47287   return jresult;
47288 }
47289
47290
47291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47292   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47293   Dali::Vector< float >::ItemType *arg2 = 0 ;
47294   Dali::Vector< float >::ItemType temp2 ;
47295
47296   arg1 = (Dali::Vector< float > *)jarg1;
47297   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47298   arg2 = &temp2;
47299   {
47300     try {
47301       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47302     } catch (std::out_of_range& e) {
47303       {
47304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47305       };
47306     } catch (std::exception& e) {
47307       {
47308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47309       };
47310     } catch (...) {
47311       {
47312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47313       };
47314     }
47315   }
47316 }
47317
47318
47319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47320   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47321   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47322   Dali::Vector< float >::ItemType *arg3 = 0 ;
47323   Dali::Vector< float >::ItemType temp3 ;
47324
47325   arg1 = (Dali::Vector< float > *)jarg1;
47326   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47327   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47328   arg3 = &temp3;
47329   {
47330     try {
47331       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47332     } catch (std::out_of_range& e) {
47333       {
47334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47335       };
47336     } catch (std::exception& e) {
47337       {
47338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47339       };
47340     } catch (...) {
47341       {
47342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47343       };
47344     }
47345   }
47346 }
47347
47348
47349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47350   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47351   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47352   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47353   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47354
47355   arg1 = (Dali::Vector< float > *)jarg1;
47356   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47357   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47358   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47359   {
47360     try {
47361       (arg1)->Insert(arg2,arg3,arg4);
47362     } catch (std::out_of_range& e) {
47363       {
47364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47365       };
47366     } catch (std::exception& e) {
47367       {
47368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47369       };
47370     } catch (...) {
47371       {
47372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47373       };
47374     }
47375   }
47376 }
47377
47378
47379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47380   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47381   Dali::Vector< float >::SizeType arg2 ;
47382
47383   arg1 = (Dali::Vector< float > *)jarg1;
47384   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47385   {
47386     try {
47387       (arg1)->Reserve(arg2);
47388     } catch (std::out_of_range& e) {
47389       {
47390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (std::exception& e) {
47393       {
47394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47395       };
47396     } catch (...) {
47397       {
47398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47399       };
47400     }
47401   }
47402 }
47403
47404
47405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47406   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47407   Dali::Vector< float >::SizeType arg2 ;
47408
47409   arg1 = (Dali::Vector< float > *)jarg1;
47410   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47411   {
47412     try {
47413       (arg1)->Resize(arg2);
47414     } catch (std::out_of_range& e) {
47415       {
47416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47417       };
47418     } catch (std::exception& e) {
47419       {
47420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47421       };
47422     } catch (...) {
47423       {
47424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47425       };
47426     }
47427   }
47428 }
47429
47430
47431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47432   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47433   Dali::Vector< float >::SizeType arg2 ;
47434   Dali::Vector< float >::ItemType *arg3 = 0 ;
47435   Dali::Vector< float >::ItemType temp3 ;
47436
47437   arg1 = (Dali::Vector< float > *)jarg1;
47438   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47439   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47440   arg3 = &temp3;
47441   {
47442     try {
47443       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47444     } catch (std::out_of_range& e) {
47445       {
47446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47447       };
47448     } catch (std::exception& e) {
47449       {
47450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47451       };
47452     } catch (...) {
47453       {
47454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47455       };
47456     }
47457   }
47458 }
47459
47460
47461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47462   void * jresult ;
47463   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47464   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47465   Dali::Vector< float >::Iterator result;
47466
47467   arg1 = (Dali::Vector< float > *)jarg1;
47468   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47469   {
47470     try {
47471       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47472     } catch (std::out_of_range& e) {
47473       {
47474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47475       };
47476     } catch (std::exception& e) {
47477       {
47478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47479       };
47480     } catch (...) {
47481       {
47482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47483       };
47484     }
47485   }
47486   jresult = (void *)result;
47487   return jresult;
47488 }
47489
47490
47491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47492   void * jresult ;
47493   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47494   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47495   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47496   Dali::Vector< float >::Iterator result;
47497
47498   arg1 = (Dali::Vector< float > *)jarg1;
47499   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47500   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47501   {
47502     try {
47503       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47504     } catch (std::out_of_range& e) {
47505       {
47506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47507       };
47508     } catch (std::exception& e) {
47509       {
47510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47511       };
47512     } catch (...) {
47513       {
47514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47515       };
47516     }
47517   }
47518   jresult = (void *)result;
47519   return jresult;
47520 }
47521
47522
47523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47524   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47525   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47526
47527   arg1 = (Dali::Vector< float > *)jarg1;
47528   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47529   {
47530     try {
47531       (arg1)->Remove(arg2);
47532     } catch (std::out_of_range& e) {
47533       {
47534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47535       };
47536     } catch (std::exception& e) {
47537       {
47538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47539       };
47540     } catch (...) {
47541       {
47542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47543       };
47544     }
47545   }
47546 }
47547
47548
47549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47550   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47551   Dali::Vector< float > *arg2 = 0 ;
47552
47553   arg1 = (Dali::Vector< float > *)jarg1;
47554   arg2 = (Dali::Vector< float > *)jarg2;
47555   if (!arg2) {
47556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47557     return ;
47558   }
47559   {
47560     try {
47561       (arg1)->Swap(*arg2);
47562     } catch (std::out_of_range& e) {
47563       {
47564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (std::exception& e) {
47567       {
47568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47569       };
47570     } catch (...) {
47571       {
47572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47573       };
47574     }
47575   }
47576 }
47577
47578
47579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47580   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47581
47582   arg1 = (Dali::Vector< float > *)jarg1;
47583   {
47584     try {
47585       (arg1)->Clear();
47586     } catch (std::out_of_range& e) {
47587       {
47588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47589       };
47590     } catch (std::exception& e) {
47591       {
47592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47593       };
47594     } catch (...) {
47595       {
47596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47597       };
47598     }
47599   }
47600 }
47601
47602
47603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47604   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47605
47606   arg1 = (Dali::Vector< float > *)jarg1;
47607   {
47608     try {
47609       (arg1)->Release();
47610     } catch (std::out_of_range& e) {
47611       {
47612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47613       };
47614     } catch (std::exception& e) {
47615       {
47616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47617       };
47618     } catch (...) {
47619       {
47620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47621       };
47622     }
47623   }
47624 }
47625
47626
47627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47628   int jresult ;
47629   int result;
47630
47631   result = (int)Dali::Vector< unsigned char >::BaseType;
47632   jresult = (int)result;
47633   return jresult;
47634 }
47635
47636
47637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47638   void * jresult ;
47639   Dali::Vector< unsigned char > *result = 0 ;
47640
47641   {
47642     try {
47643       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47644     } catch (std::out_of_range& e) {
47645       {
47646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47647       };
47648     } catch (std::exception& e) {
47649       {
47650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47651       };
47652     } catch (...) {
47653       {
47654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47655       };
47656     }
47657   }
47658   jresult = (void *)result;
47659   return jresult;
47660 }
47661
47662
47663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47664   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47665
47666   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47667   {
47668     try {
47669       delete arg1;
47670     } catch (std::out_of_range& e) {
47671       {
47672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47673       };
47674     } catch (std::exception& e) {
47675       {
47676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47677       };
47678     } catch (...) {
47679       {
47680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47681       };
47682     }
47683   }
47684 }
47685
47686
47687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47688   void * jresult ;
47689   Dali::Vector< unsigned char > *arg1 = 0 ;
47690   Dali::Vector< unsigned char > *result = 0 ;
47691
47692   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47693   if (!arg1) {
47694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47695     return 0;
47696   }
47697   {
47698     try {
47699       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47700     } catch (std::out_of_range& e) {
47701       {
47702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47703       };
47704     } catch (std::exception& e) {
47705       {
47706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47707       };
47708     } catch (...) {
47709       {
47710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47711       };
47712     }
47713   }
47714   jresult = (void *)result;
47715   return jresult;
47716 }
47717
47718
47719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47720   void * jresult ;
47721   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47722   Dali::Vector< unsigned char > *arg2 = 0 ;
47723   Dali::Vector< unsigned char > *result = 0 ;
47724
47725   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47726   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47727   if (!arg2) {
47728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47729     return 0;
47730   }
47731   {
47732     try {
47733       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47734     } catch (std::out_of_range& e) {
47735       {
47736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (std::exception& e) {
47739       {
47740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (...) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47745       };
47746     }
47747   }
47748   jresult = (void *)result;
47749   return jresult;
47750 }
47751
47752
47753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47754   void * jresult ;
47755   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47756   Dali::Vector< unsigned char >::Iterator result;
47757
47758   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47759   {
47760     try {
47761       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47762     } catch (std::out_of_range& e) {
47763       {
47764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47765       };
47766     } catch (std::exception& e) {
47767       {
47768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47769       };
47770     } catch (...) {
47771       {
47772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47773       };
47774     }
47775   }
47776   jresult = (void *)result;
47777   return jresult;
47778 }
47779
47780
47781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47782   void * jresult ;
47783   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47784   Dali::Vector< unsigned char >::Iterator result;
47785
47786   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47787   {
47788     try {
47789       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47790     } catch (std::out_of_range& e) {
47791       {
47792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47793       };
47794     } catch (std::exception& e) {
47795       {
47796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47797       };
47798     } catch (...) {
47799       {
47800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47801       };
47802     }
47803   }
47804   jresult = (void *)result;
47805   return jresult;
47806 }
47807
47808
47809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47810   void * jresult ;
47811   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47812   Dali::Vector< unsigned char >::SizeType arg2 ;
47813   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47814
47815   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47816   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47817   {
47818     try {
47819       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47827       };
47828     } catch (...) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47831       };
47832     }
47833   }
47834   jresult = (void *)result;
47835   return jresult;
47836 }
47837
47838
47839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47840   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47841   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47842   Dali::Vector< unsigned char >::ItemType temp2 ;
47843
47844   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47845   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47846   arg2 = &temp2;
47847   {
47848     try {
47849       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47850     } catch (std::out_of_range& e) {
47851       {
47852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47853       };
47854     } catch (std::exception& e) {
47855       {
47856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47857       };
47858     } catch (...) {
47859       {
47860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47861       };
47862     }
47863   }
47864 }
47865
47866
47867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47868   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47869   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47870   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47871   Dali::Vector< unsigned char >::ItemType temp3 ;
47872
47873   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47874   arg2 = jarg2;
47875   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47876   arg3 = &temp3;
47877   {
47878     try {
47879       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47887       };
47888     } catch (...) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47891       };
47892     }
47893   }
47894
47895
47896 }
47897
47898
47899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47900   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47901   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47902   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47903   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47904
47905   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47906   arg2 = jarg2;
47907   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47908   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47909   {
47910     try {
47911       (arg1)->Insert(arg2,arg3,arg4);
47912     } catch (std::out_of_range& e) {
47913       {
47914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47915       };
47916     } catch (std::exception& e) {
47917       {
47918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47919       };
47920     } catch (...) {
47921       {
47922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47923       };
47924     }
47925   }
47926
47927
47928 }
47929
47930
47931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47932   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47933   Dali::Vector< unsigned char >::SizeType arg2 ;
47934
47935   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47936   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47937   {
47938     try {
47939       (arg1)->Reserve(arg2);
47940     } catch (std::out_of_range& e) {
47941       {
47942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47943       };
47944     } catch (std::exception& e) {
47945       {
47946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47947       };
47948     } catch (...) {
47949       {
47950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47951       };
47952     }
47953   }
47954 }
47955
47956
47957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47958   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47959   Dali::Vector< unsigned char >::SizeType arg2 ;
47960
47961   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47962   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47963   {
47964     try {
47965       (arg1)->Resize(arg2);
47966     } catch (std::out_of_range& e) {
47967       {
47968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47969       };
47970     } catch (std::exception& e) {
47971       {
47972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47973       };
47974     } catch (...) {
47975       {
47976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47977       };
47978     }
47979   }
47980 }
47981
47982
47983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47984   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47985   Dali::Vector< unsigned char >::SizeType arg2 ;
47986   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47987   Dali::Vector< unsigned char >::ItemType temp3 ;
47988
47989   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47990   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47991   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47992   arg3 = &temp3;
47993   {
47994     try {
47995       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47996     } catch (std::out_of_range& e) {
47997       {
47998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47999       };
48000     } catch (std::exception& e) {
48001       {
48002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48003       };
48004     } catch (...) {
48005       {
48006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48007       };
48008     }
48009   }
48010 }
48011
48012
48013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48014   void * jresult ;
48015   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48016   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48017   Dali::Vector< unsigned char >::Iterator result;
48018
48019   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48020   arg2 = jarg2;
48021   {
48022     try {
48023       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48024     } catch (std::out_of_range& e) {
48025       {
48026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48027       };
48028     } catch (std::exception& e) {
48029       {
48030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48031       };
48032     } catch (...) {
48033       {
48034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48035       };
48036     }
48037   }
48038   jresult = (void *)result;
48039
48040
48041   return jresult;
48042 }
48043
48044
48045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48046   void * jresult ;
48047   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48048   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48049   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48050   Dali::Vector< unsigned char >::Iterator result;
48051
48052   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48053   arg2 = jarg2;
48054   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48055   {
48056     try {
48057       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48058     } catch (std::out_of_range& e) {
48059       {
48060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48061       };
48062     } catch (std::exception& e) {
48063       {
48064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48065       };
48066     } catch (...) {
48067       {
48068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48069       };
48070     }
48071   }
48072   jresult = (void *)result;
48073
48074
48075   return jresult;
48076 }
48077
48078
48079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48080   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48081   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48082
48083   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48084   arg2 = jarg2;
48085   {
48086     try {
48087       (arg1)->Remove(arg2);
48088     } catch (std::out_of_range& e) {
48089       {
48090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48091       };
48092     } catch (std::exception& e) {
48093       {
48094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48095       };
48096     } catch (...) {
48097       {
48098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48099       };
48100     }
48101   }
48102
48103
48104 }
48105
48106
48107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48108   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48109   Dali::Vector< unsigned char > *arg2 = 0 ;
48110
48111   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48112   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48113   if (!arg2) {
48114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48115     return ;
48116   }
48117   {
48118     try {
48119       (arg1)->Swap(*arg2);
48120     } catch (std::out_of_range& e) {
48121       {
48122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (std::exception& e) {
48125       {
48126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48127       };
48128     } catch (...) {
48129       {
48130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48131       };
48132     }
48133   }
48134 }
48135
48136
48137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48138   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48139
48140   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48141   {
48142     try {
48143       (arg1)->Clear();
48144     } catch (std::out_of_range& e) {
48145       {
48146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48147       };
48148     } catch (std::exception& e) {
48149       {
48150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48151       };
48152     } catch (...) {
48153       {
48154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48155       };
48156     }
48157   }
48158 }
48159
48160
48161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48162   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48163
48164   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48165   {
48166     try {
48167       (arg1)->Release();
48168     } catch (std::out_of_range& e) {
48169       {
48170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48171       };
48172     } catch (std::exception& e) {
48173       {
48174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48175       };
48176     } catch (...) {
48177       {
48178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48179       };
48180     }
48181   }
48182 }
48183
48184
48185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48186   int jresult ;
48187   int result;
48188
48189   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48190   jresult = (int)result;
48191   return jresult;
48192 }
48193
48194
48195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48196   void * jresult ;
48197   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48198
48199   {
48200     try {
48201       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48202     } catch (std::out_of_range& e) {
48203       {
48204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48205       };
48206     } catch (std::exception& e) {
48207       {
48208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48209       };
48210     } catch (...) {
48211       {
48212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48213       };
48214     }
48215   }
48216   jresult = (void *)result;
48217   return jresult;
48218 }
48219
48220
48221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48222   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48223
48224   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48225   {
48226     try {
48227       delete arg1;
48228     } catch (std::out_of_range& e) {
48229       {
48230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48231       };
48232     } catch (std::exception& e) {
48233       {
48234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48235       };
48236     } catch (...) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48239       };
48240     }
48241   }
48242 }
48243
48244
48245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48246   void * jresult ;
48247   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48248   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48249
48250   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48251   if (!arg1) {
48252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48253     return 0;
48254   }
48255   {
48256     try {
48257       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48258     } catch (std::out_of_range& e) {
48259       {
48260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48261       };
48262     } catch (std::exception& e) {
48263       {
48264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48265       };
48266     } catch (...) {
48267       {
48268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48269       };
48270     }
48271   }
48272   jresult = (void *)result;
48273   return jresult;
48274 }
48275
48276
48277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48278   void * jresult ;
48279   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48280   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48281   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48282
48283   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48284   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48285   if (!arg2) {
48286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48287     return 0;
48288   }
48289   {
48290     try {
48291       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48292     } catch (std::out_of_range& e) {
48293       {
48294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (std::exception& e) {
48297       {
48298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48299       };
48300     } catch (...) {
48301       {
48302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48303       };
48304     }
48305   }
48306   jresult = (void *)result;
48307   return jresult;
48308 }
48309
48310
48311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48312   void * jresult ;
48313   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48314   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48315
48316   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48317   {
48318     try {
48319       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48320     } catch (std::out_of_range& e) {
48321       {
48322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48323       };
48324     } catch (std::exception& e) {
48325       {
48326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48327       };
48328     } catch (...) {
48329       {
48330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48331       };
48332     }
48333   }
48334   jresult = (void *)result;
48335   return jresult;
48336 }
48337
48338
48339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48340   void * jresult ;
48341   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48342   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48343
48344   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48345   {
48346     try {
48347       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48348     } catch (std::out_of_range& e) {
48349       {
48350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48351       };
48352     } catch (std::exception& e) {
48353       {
48354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48355       };
48356     } catch (...) {
48357       {
48358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48359       };
48360     }
48361   }
48362   jresult = (void *)result;
48363   return jresult;
48364 }
48365
48366
48367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48368   void * jresult ;
48369   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48370   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48371   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48372
48373   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48374   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48375   {
48376     try {
48377       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48378     } catch (std::out_of_range& e) {
48379       {
48380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48381       };
48382     } catch (std::exception& e) {
48383       {
48384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48385       };
48386     } catch (...) {
48387       {
48388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48389       };
48390     }
48391   }
48392   jresult = (void *)result;
48393   return jresult;
48394 }
48395
48396
48397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48398   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48399   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48400
48401   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48402   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48403   if (!arg2) {
48404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48405     return ;
48406   }
48407   {
48408     try {
48409       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48410     } catch (std::out_of_range& e) {
48411       {
48412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (std::exception& e) {
48415       {
48416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (...) {
48419       {
48420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48421       };
48422     }
48423   }
48424 }
48425
48426
48427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48428   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48429   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48430   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48431
48432   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48433   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48434   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48435   if (!arg3) {
48436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48437     return ;
48438   }
48439   {
48440     try {
48441       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48442     } catch (std::out_of_range& e) {
48443       {
48444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (std::exception& e) {
48447       {
48448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48449       };
48450     } catch (...) {
48451       {
48452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48453       };
48454     }
48455   }
48456 }
48457
48458
48459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48460   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48461   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48462   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48463   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48464
48465   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48466   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48467   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48468   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48469   {
48470     try {
48471       (arg1)->Insert(arg2,arg3,arg4);
48472     } catch (std::out_of_range& e) {
48473       {
48474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48475       };
48476     } catch (std::exception& e) {
48477       {
48478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48479       };
48480     } catch (...) {
48481       {
48482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48483       };
48484     }
48485   }
48486 }
48487
48488
48489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48490   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48491   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48492
48493   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48494   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48495   {
48496     try {
48497       (arg1)->Reserve(arg2);
48498     } catch (std::out_of_range& e) {
48499       {
48500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48501       };
48502     } catch (std::exception& e) {
48503       {
48504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48505       };
48506     } catch (...) {
48507       {
48508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48509       };
48510     }
48511   }
48512 }
48513
48514
48515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48516   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48517   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48518
48519   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48520   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48521   {
48522     try {
48523       (arg1)->Resize(arg2);
48524     } catch (std::out_of_range& e) {
48525       {
48526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48527       };
48528     } catch (std::exception& e) {
48529       {
48530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48531       };
48532     } catch (...) {
48533       {
48534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48535       };
48536     }
48537   }
48538 }
48539
48540
48541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48542   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48543   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48544   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48545
48546   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48547   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48548   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48549   if (!arg3) {
48550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48551     return ;
48552   }
48553   {
48554     try {
48555       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48556     } catch (std::out_of_range& e) {
48557       {
48558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (std::exception& e) {
48561       {
48562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48563       };
48564     } catch (...) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48567       };
48568     }
48569   }
48570 }
48571
48572
48573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48574   void * jresult ;
48575   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48576   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48577   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48578
48579   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48580   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48581   {
48582     try {
48583       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48584     } catch (std::out_of_range& e) {
48585       {
48586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48587       };
48588     } catch (std::exception& e) {
48589       {
48590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48591       };
48592     } catch (...) {
48593       {
48594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48595       };
48596     }
48597   }
48598   jresult = (void *)result;
48599   return jresult;
48600 }
48601
48602
48603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48604   void * jresult ;
48605   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48606   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48607   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48608   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48609
48610   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48611   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48612   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48613   {
48614     try {
48615       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48627       };
48628     }
48629   }
48630   jresult = (void *)result;
48631   return jresult;
48632 }
48633
48634
48635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48636   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48637   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48638
48639   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48640   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48641   {
48642     try {
48643       (arg1)->Remove(arg2);
48644     } catch (std::out_of_range& e) {
48645       {
48646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (std::exception& e) {
48649       {
48650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48651       };
48652     } catch (...) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48655       };
48656     }
48657   }
48658 }
48659
48660
48661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48662   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48663   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48664
48665   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48666   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48667   if (!arg2) {
48668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48669     return ;
48670   }
48671   {
48672     try {
48673       (arg1)->Swap(*arg2);
48674     } catch (std::out_of_range& e) {
48675       {
48676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (std::exception& e) {
48679       {
48680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48681       };
48682     } catch (...) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48685       };
48686     }
48687   }
48688 }
48689
48690
48691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48692   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48693
48694   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48695   {
48696     try {
48697       (arg1)->Clear();
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (...) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48709       };
48710     }
48711   }
48712 }
48713
48714
48715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48716   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48717
48718   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48719   {
48720     try {
48721       (arg1)->Release();
48722     } catch (std::out_of_range& e) {
48723       {
48724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48725       };
48726     } catch (std::exception& e) {
48727       {
48728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48729       };
48730     } catch (...) {
48731       {
48732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48733       };
48734     }
48735   }
48736 }
48737
48738
48739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48740   void * jresult ;
48741   Dali::Signal< void () > *result = 0 ;
48742
48743   {
48744     try {
48745       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48746     } catch (std::out_of_range& e) {
48747       {
48748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48749       };
48750     } catch (std::exception& e) {
48751       {
48752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48753       };
48754     } catch (...) {
48755       {
48756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48757       };
48758     }
48759   }
48760   jresult = (void *)result;
48761   return jresult;
48762 }
48763
48764
48765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48766   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48767
48768   arg1 = (Dali::Signal< void () > *)jarg1;
48769   {
48770     try {
48771       delete arg1;
48772     } catch (std::out_of_range& e) {
48773       {
48774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (std::exception& e) {
48777       {
48778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48779       };
48780     } catch (...) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48783       };
48784     }
48785   }
48786 }
48787
48788
48789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48790   unsigned int jresult ;
48791   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48792   bool result;
48793
48794   arg1 = (Dali::Signal< void () > *)jarg1;
48795   {
48796     try {
48797       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48798     } catch (std::out_of_range& e) {
48799       {
48800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48801       };
48802     } catch (std::exception& e) {
48803       {
48804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48805       };
48806     } catch (...) {
48807       {
48808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48809       };
48810     }
48811   }
48812   jresult = result;
48813   return jresult;
48814 }
48815
48816
48817 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48818   unsigned long jresult ;
48819   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48820   std::size_t result;
48821
48822   arg1 = (Dali::Signal< void () > *)jarg1;
48823   {
48824     try {
48825       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48826     } catch (std::out_of_range& e) {
48827       {
48828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48829       };
48830     } catch (std::exception& e) {
48831       {
48832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48833       };
48834     } catch (...) {
48835       {
48836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48837       };
48838     }
48839   }
48840   jresult = (unsigned long)result;
48841   return jresult;
48842 }
48843
48844
48845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48846   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48847   void (*arg2)() = (void (*)()) 0 ;
48848
48849   arg1 = (Dali::Signal< void () > *)jarg1;
48850   arg2 = (void (*)())jarg2;
48851   {
48852     try {
48853       (arg1)->Connect(arg2);
48854     } catch (std::out_of_range& e) {
48855       {
48856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48857       };
48858     } catch (std::exception& e) {
48859       {
48860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48861       };
48862     } catch (...) {
48863       {
48864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48865       };
48866     }
48867   }
48868 }
48869
48870
48871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48872   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48873   void (*arg2)() = (void (*)()) 0 ;
48874
48875   arg1 = (Dali::Signal< void () > *)jarg1;
48876   arg2 = (void (*)())jarg2;
48877   {
48878     try {
48879       (arg1)->Disconnect(arg2);
48880     } catch (std::out_of_range& e) {
48881       {
48882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (std::exception& e) {
48885       {
48886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48887       };
48888     } catch (...) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48891       };
48892     }
48893   }
48894 }
48895
48896
48897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48898   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48899   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48900   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48901
48902   arg1 = (Dali::Signal< void () > *)jarg1;
48903   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48904   arg3 = (Dali::FunctorDelegate *)jarg3;
48905   {
48906     try {
48907       (arg1)->Connect(arg2,arg3);
48908     } catch (std::out_of_range& e) {
48909       {
48910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48911       };
48912     } catch (std::exception& e) {
48913       {
48914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48915       };
48916     } catch (...) {
48917       {
48918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48919       };
48920     }
48921   }
48922 }
48923
48924
48925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48926   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48927
48928   arg1 = (Dali::Signal< void () > *)jarg1;
48929   {
48930     try {
48931       (arg1)->Emit();
48932     } catch (std::out_of_range& e) {
48933       {
48934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48935       };
48936     } catch (std::exception& e) {
48937       {
48938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48939       };
48940     } catch (...) {
48941       {
48942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48943       };
48944     }
48945   }
48946 }
48947
48948
48949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48950   unsigned int jresult ;
48951   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48952   bool result;
48953
48954   arg1 = (Dali::Signal< void (float) > *)jarg1;
48955   {
48956     try {
48957       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48965       };
48966     } catch (...) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48969       };
48970     }
48971   }
48972   jresult = result;
48973   return jresult;
48974 }
48975
48976
48977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48978   unsigned long jresult ;
48979   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48980   std::size_t result;
48981
48982   arg1 = (Dali::Signal< void (float) > *)jarg1;
48983   {
48984     try {
48985       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48986     } catch (std::out_of_range& e) {
48987       {
48988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48989       };
48990     } catch (std::exception& e) {
48991       {
48992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48993       };
48994     } catch (...) {
48995       {
48996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48997       };
48998     }
48999   }
49000   jresult = (unsigned long)result;
49001   return jresult;
49002 }
49003
49004
49005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49006   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49007   void (*arg2)(float) = (void (*)(float)) 0 ;
49008
49009   arg1 = (Dali::Signal< void (float) > *)jarg1;
49010   arg2 = (void (*)(float))jarg2;
49011   {
49012     try {
49013       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49014     } catch (std::out_of_range& e) {
49015       {
49016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49017       };
49018     } catch (std::exception& e) {
49019       {
49020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49021       };
49022     } catch (...) {
49023       {
49024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49025       };
49026     }
49027   }
49028 }
49029
49030
49031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49032   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49033   void (*arg2)(float) = (void (*)(float)) 0 ;
49034
49035   arg1 = (Dali::Signal< void (float) > *)jarg1;
49036   arg2 = (void (*)(float))jarg2;
49037   {
49038     try {
49039       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49040     } catch (std::out_of_range& e) {
49041       {
49042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49043       };
49044     } catch (std::exception& e) {
49045       {
49046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (...) {
49049       {
49050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49051       };
49052     }
49053   }
49054 }
49055
49056
49057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49058   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49059   float arg2 ;
49060
49061   arg1 = (Dali::Signal< void (float) > *)jarg1;
49062   arg2 = (float)jarg2;
49063   {
49064     try {
49065       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49073       };
49074     } catch (...) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49077       };
49078     }
49079   }
49080 }
49081
49082
49083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49084   void * jresult ;
49085   Dali::Signal< void (float) > *result = 0 ;
49086
49087   {
49088     try {
49089       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49090     } catch (std::out_of_range& e) {
49091       {
49092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49093       };
49094     } catch (std::exception& e) {
49095       {
49096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49097       };
49098     } catch (...) {
49099       {
49100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49101       };
49102     }
49103   }
49104   jresult = (void *)result;
49105   return jresult;
49106 }
49107
49108
49109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49110   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49111
49112   arg1 = (Dali::Signal< void (float) > *)jarg1;
49113   {
49114     try {
49115       delete arg1;
49116     } catch (std::out_of_range& e) {
49117       {
49118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (std::exception& e) {
49121       {
49122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49123       };
49124     } catch (...) {
49125       {
49126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49127       };
49128     }
49129   }
49130 }
49131
49132
49133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49134   unsigned int jresult ;
49135   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49136   bool result;
49137
49138   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49139   {
49140     try {
49141       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49142     } catch (std::out_of_range& e) {
49143       {
49144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49145       };
49146     } catch (std::exception& e) {
49147       {
49148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49149       };
49150     } catch (...) {
49151       {
49152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49153       };
49154     }
49155   }
49156   jresult = result;
49157   return jresult;
49158 }
49159
49160
49161 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49162   unsigned long jresult ;
49163   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49164   std::size_t result;
49165
49166   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49167   {
49168     try {
49169       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49170     } catch (std::out_of_range& e) {
49171       {
49172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49173       };
49174     } catch (std::exception& e) {
49175       {
49176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49177       };
49178     } catch (...) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49181       };
49182     }
49183   }
49184   jresult = (unsigned long)result;
49185   return jresult;
49186 }
49187
49188
49189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49190   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49191   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49192
49193   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49194   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49195   {
49196     try {
49197       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49198     } catch (std::out_of_range& e) {
49199       {
49200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49201       };
49202     } catch (std::exception& e) {
49203       {
49204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49205       };
49206     } catch (...) {
49207       {
49208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49209       };
49210     }
49211   }
49212 }
49213
49214
49215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49216   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49217   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49218
49219   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49220   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49221   {
49222     try {
49223       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49224     } catch (std::out_of_range& e) {
49225       {
49226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49227       };
49228     } catch (std::exception& e) {
49229       {
49230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49231       };
49232     } catch (...) {
49233       {
49234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49235       };
49236     }
49237   }
49238 }
49239
49240
49241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49242   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49243   Dali::BaseHandle arg2 ;
49244   Dali::BaseHandle *argp2 ;
49245
49246   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49247   argp2 = (Dali::BaseHandle *)jarg2;
49248   if (!argp2) {
49249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49250     return ;
49251   }
49252   arg2 = *argp2;
49253   {
49254     try {
49255       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49256     } catch (std::out_of_range& e) {
49257       {
49258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49259       };
49260     } catch (std::exception& e) {
49261       {
49262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49263       };
49264     } catch (...) {
49265       {
49266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49267       };
49268     }
49269   }
49270 }
49271
49272
49273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49274   void * jresult ;
49275   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49276
49277   {
49278     try {
49279       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49280     } catch (std::out_of_range& e) {
49281       {
49282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (std::exception& e) {
49285       {
49286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49287       };
49288     } catch (...) {
49289       {
49290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49291       };
49292     }
49293   }
49294   jresult = (void *)result;
49295   return jresult;
49296 }
49297
49298
49299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49300   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49301
49302   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49303   {
49304     try {
49305       delete arg1;
49306     } catch (std::out_of_range& e) {
49307       {
49308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (std::exception& e) {
49311       {
49312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320 }
49321
49322
49323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49324   unsigned int jresult ;
49325   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49326   bool result;
49327
49328   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49329   {
49330     try {
49331       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49332     } catch (std::out_of_range& e) {
49333       {
49334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49335       };
49336     } catch (std::exception& e) {
49337       {
49338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (...) {
49341       {
49342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49343       };
49344     }
49345   }
49346   jresult = result;
49347   return jresult;
49348 }
49349
49350
49351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49352   unsigned long jresult ;
49353   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49354   std::size_t result;
49355
49356   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49357   {
49358     try {
49359       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49360     } catch (std::out_of_range& e) {
49361       {
49362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (std::exception& e) {
49365       {
49366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49367       };
49368     } catch (...) {
49369       {
49370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49371       };
49372     }
49373   }
49374   jresult = (unsigned long)result;
49375   return jresult;
49376 }
49377
49378
49379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49380   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49381   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49382
49383   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49384   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49385   {
49386     try {
49387       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49388     } catch (std::out_of_range& e) {
49389       {
49390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49391       };
49392     } catch (std::exception& e) {
49393       {
49394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49395       };
49396     } catch (...) {
49397       {
49398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49399       };
49400     }
49401   }
49402 }
49403
49404
49405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49406   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49407   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49408
49409   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49410   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49411   {
49412     try {
49413       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49414     } catch (std::out_of_range& e) {
49415       {
49416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49417       };
49418     } catch (std::exception& e) {
49419       {
49420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49421       };
49422     } catch (...) {
49423       {
49424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49425       };
49426     }
49427   }
49428 }
49429
49430
49431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49432   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49433   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49434
49435   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49436   arg2 = (Dali::RefObject *)jarg2;
49437   {
49438     try {
49439       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49440     } catch (std::out_of_range& e) {
49441       {
49442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49443       };
49444     } catch (std::exception& e) {
49445       {
49446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49447       };
49448     } catch (...) {
49449       {
49450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49451       };
49452     }
49453   }
49454 }
49455
49456
49457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49458   void * jresult ;
49459   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49460
49461   {
49462     try {
49463       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49464     } catch (std::out_of_range& e) {
49465       {
49466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (std::exception& e) {
49469       {
49470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49471       };
49472     } catch (...) {
49473       {
49474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49475       };
49476     }
49477   }
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49484   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49485
49486   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49487   {
49488     try {
49489       delete arg1;
49490     } catch (std::out_of_range& e) {
49491       {
49492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49493       };
49494     } catch (std::exception& e) {
49495       {
49496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49497       };
49498     } catch (...) {
49499       {
49500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49501       };
49502     }
49503   }
49504 }
49505
49506
49507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49508   unsigned int jresult ;
49509   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49510   bool result;
49511
49512   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49513   {
49514     try {
49515       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49516     } catch (std::out_of_range& e) {
49517       {
49518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49519       };
49520     } catch (std::exception& e) {
49521       {
49522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49523       };
49524     } catch (...) {
49525       {
49526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49527       };
49528     }
49529   }
49530   jresult = result;
49531   return jresult;
49532 }
49533
49534
49535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49536   unsigned long jresult ;
49537   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49538   std::size_t result;
49539
49540   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49541   {
49542     try {
49543       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49544     } catch (std::out_of_range& e) {
49545       {
49546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (std::exception& e) {
49549       {
49550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49551       };
49552     } catch (...) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49555       };
49556     }
49557   }
49558   jresult = (unsigned long)result;
49559   return jresult;
49560 }
49561
49562
49563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49564   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49565   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49566
49567   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49568   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49569   {
49570     try {
49571       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49572     } catch (std::out_of_range& e) {
49573       {
49574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49575       };
49576     } catch (std::exception& e) {
49577       {
49578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49579       };
49580     } catch (...) {
49581       {
49582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49583       };
49584     }
49585   }
49586 }
49587
49588
49589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49590   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49591   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49592
49593   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49594   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49595   {
49596     try {
49597       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49598     } catch (std::out_of_range& e) {
49599       {
49600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49601       };
49602     } catch (std::exception& e) {
49603       {
49604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49605       };
49606     } catch (...) {
49607       {
49608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49609       };
49610     }
49611   }
49612 }
49613
49614
49615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49617   Dali::PropertyNotification *arg2 = 0 ;
49618
49619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49620   arg2 = (Dali::PropertyNotification *)jarg2;
49621   if (!arg2) {
49622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49623     return ;
49624   }
49625   {
49626     try {
49627       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49628     } catch (std::out_of_range& e) {
49629       {
49630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49631       };
49632     } catch (std::exception& e) {
49633       {
49634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49635       };
49636     } catch (...) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49639       };
49640     }
49641   }
49642 }
49643
49644
49645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49646   void * jresult ;
49647   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49648
49649   {
49650     try {
49651       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49652     } catch (std::out_of_range& e) {
49653       {
49654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49655       };
49656     } catch (std::exception& e) {
49657       {
49658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49659       };
49660     } catch (...) {
49661       {
49662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49663       };
49664     }
49665   }
49666   jresult = (void *)result;
49667   return jresult;
49668 }
49669
49670
49671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49672   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49673
49674   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49675   {
49676     try {
49677       delete arg1;
49678     } catch (std::out_of_range& e) {
49679       {
49680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (std::exception& e) {
49683       {
49684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49685       };
49686     } catch (...) {
49687       {
49688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49689       };
49690     }
49691   }
49692 }
49693
49694
49695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49696   unsigned int jresult ;
49697   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49698   bool result;
49699
49700   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49701   {
49702     try {
49703       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49704     } catch (std::out_of_range& e) {
49705       {
49706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49707       };
49708     } catch (std::exception& e) {
49709       {
49710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49711       };
49712     } catch (...) {
49713       {
49714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49715       };
49716     }
49717   }
49718   jresult = result;
49719   return jresult;
49720 }
49721
49722
49723 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49724   unsigned long jresult ;
49725   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49726   std::size_t result;
49727
49728   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49729   {
49730     try {
49731       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49732     } catch (std::out_of_range& e) {
49733       {
49734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49735       };
49736     } catch (std::exception& e) {
49737       {
49738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49739       };
49740     } catch (...) {
49741       {
49742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49743       };
49744     }
49745   }
49746   jresult = (unsigned long)result;
49747   return jresult;
49748 }
49749
49750
49751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49752   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49753   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49754
49755   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49756   arg2 = (void (*)(Dali::Image))jarg2;
49757   {
49758     try {
49759       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49760     } catch (std::out_of_range& e) {
49761       {
49762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (std::exception& e) {
49765       {
49766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774 }
49775
49776
49777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49778   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49779   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49780
49781   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49782   arg2 = (void (*)(Dali::Image))jarg2;
49783   {
49784     try {
49785       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49786     } catch (std::out_of_range& e) {
49787       {
49788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (std::exception& e) {
49791       {
49792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49793       };
49794     } catch (...) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49797       };
49798     }
49799   }
49800 }
49801
49802
49803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49804   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49805   Dali::Image arg2 ;
49806   Dali::Image *argp2 ;
49807
49808   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49809   argp2 = (Dali::Image *)jarg2;
49810   if (!argp2) {
49811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49812     return ;
49813   }
49814   arg2 = *argp2;
49815   {
49816     try {
49817       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49818     } catch (std::out_of_range& e) {
49819       {
49820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (std::exception& e) {
49823       {
49824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49825       };
49826     } catch (...) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49829       };
49830     }
49831   }
49832 }
49833
49834
49835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49836   void * jresult ;
49837   Dali::Signal< void (Dali::Image) > *result = 0 ;
49838
49839   {
49840     try {
49841       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49842     } catch (std::out_of_range& e) {
49843       {
49844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49845       };
49846     } catch (std::exception& e) {
49847       {
49848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49849       };
49850     } catch (...) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49853       };
49854     }
49855   }
49856   jresult = (void *)result;
49857   return jresult;
49858 }
49859
49860
49861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49862   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49863
49864   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49865   {
49866     try {
49867       delete arg1;
49868     } catch (std::out_of_range& e) {
49869       {
49870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (std::exception& e) {
49873       {
49874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49875       };
49876     } catch (...) {
49877       {
49878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49879       };
49880     }
49881   }
49882 }
49883
49884
49885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49886   void * jresult ;
49887   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49888
49889   {
49890     try {
49891       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49892     } catch (std::out_of_range& e) {
49893       {
49894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49895       };
49896     } catch (std::exception& e) {
49897       {
49898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49899       };
49900     } catch (...) {
49901       {
49902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49903       };
49904     }
49905   }
49906   jresult = (void *)result;
49907   return jresult;
49908 }
49909
49910
49911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49912   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49913
49914   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49915   {
49916     try {
49917       delete arg1;
49918     } catch (std::out_of_range& e) {
49919       {
49920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (std::exception& e) {
49923       {
49924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49925       };
49926     } catch (...) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49929       };
49930     }
49931   }
49932 }
49933
49934
49935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49936   unsigned int jresult ;
49937   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49938   bool result;
49939
49940   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49941   {
49942     try {
49943       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);
49944     } catch (std::out_of_range& e) {
49945       {
49946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49947       };
49948     } catch (std::exception& e) {
49949       {
49950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49951       };
49952     } catch (...) {
49953       {
49954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49955       };
49956     }
49957   }
49958   jresult = result;
49959   return jresult;
49960 }
49961
49962
49963 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49964   unsigned long jresult ;
49965   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49966   std::size_t result;
49967
49968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49969   {
49970     try {
49971       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);
49972     } catch (std::out_of_range& e) {
49973       {
49974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49975       };
49976     } catch (std::exception& e) {
49977       {
49978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49979       };
49980     } catch (...) {
49981       {
49982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49983       };
49984     }
49985   }
49986   jresult = (unsigned long)result;
49987   return jresult;
49988 }
49989
49990
49991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49992   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49993   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49994
49995   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49996   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49997   {
49998     try {
49999       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50000     } catch (std::out_of_range& e) {
50001       {
50002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (std::exception& e) {
50005       {
50006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50007       };
50008     } catch (...) {
50009       {
50010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50011       };
50012     }
50013   }
50014 }
50015
50016
50017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50018   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50019   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50020
50021   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50022   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50023   {
50024     try {
50025       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50026     } catch (std::out_of_range& e) {
50027       {
50028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50029       };
50030     } catch (std::exception& e) {
50031       {
50032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50033       };
50034     } catch (...) {
50035       {
50036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50037       };
50038     }
50039   }
50040 }
50041
50042
50043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50044   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50045   Dali::Actor arg2 ;
50046   Dali::LongPressGesture *arg3 = 0 ;
50047   Dali::Actor *argp2 ;
50048
50049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50050   argp2 = (Dali::Actor *)jarg2;
50051   if (!argp2) {
50052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50053     return ;
50054   }
50055   arg2 = *argp2;
50056   arg3 = (Dali::LongPressGesture *)jarg3;
50057   if (!arg3) {
50058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50059     return ;
50060   }
50061   {
50062     try {
50063       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50064     } catch (std::out_of_range& e) {
50065       {
50066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50067       };
50068     } catch (std::exception& e) {
50069       {
50070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50075       };
50076     }
50077   }
50078 }
50079
50080
50081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50082   void * jresult ;
50083   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50084
50085   {
50086     try {
50087       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50088     } catch (std::out_of_range& e) {
50089       {
50090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50091       };
50092     } catch (std::exception& e) {
50093       {
50094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50095       };
50096     } catch (...) {
50097       {
50098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50099       };
50100     }
50101   }
50102   jresult = (void *)result;
50103   return jresult;
50104 }
50105
50106
50107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50108   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50109
50110   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50111   {
50112     try {
50113       delete arg1;
50114     } catch (std::out_of_range& e) {
50115       {
50116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50117       };
50118     } catch (std::exception& e) {
50119       {
50120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50121       };
50122     } catch (...) {
50123       {
50124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50125       };
50126     }
50127   }
50128 }
50129
50130
50131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50132   unsigned int jresult ;
50133   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50134   bool result;
50135
50136   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50137   {
50138     try {
50139       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);
50140     } catch (std::out_of_range& e) {
50141       {
50142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (std::exception& e) {
50145       {
50146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50147       };
50148     } catch (...) {
50149       {
50150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50151       };
50152     }
50153   }
50154   jresult = result;
50155   return jresult;
50156 }
50157
50158
50159 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50160   unsigned long jresult ;
50161   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50162   std::size_t result;
50163
50164   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50165   {
50166     try {
50167       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);
50168     } catch (std::out_of_range& e) {
50169       {
50170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50171       };
50172     } catch (std::exception& e) {
50173       {
50174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50175       };
50176     } catch (...) {
50177       {
50178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50179       };
50180     }
50181   }
50182   jresult = (unsigned long)result;
50183   return jresult;
50184 }
50185
50186
50187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50188   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50189   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50190
50191   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50192   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50193   {
50194     try {
50195       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50196     } catch (std::out_of_range& e) {
50197       {
50198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (std::exception& e) {
50201       {
50202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50203       };
50204     } catch (...) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50207       };
50208     }
50209   }
50210 }
50211
50212
50213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50214   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50215   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50216
50217   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50218   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50219   {
50220     try {
50221       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50222     } catch (std::out_of_range& e) {
50223       {
50224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50225       };
50226     } catch (std::exception& e) {
50227       {
50228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50229       };
50230     } catch (...) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50233       };
50234     }
50235   }
50236 }
50237
50238
50239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50240   unsigned int jresult ;
50241   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50242   Dali::Actor arg2 ;
50243   Dali::TouchData *arg3 = 0 ;
50244   Dali::Actor *argp2 ;
50245   bool result;
50246
50247   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50248   argp2 = (Dali::Actor *)jarg2;
50249   if (!argp2) {
50250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50251     return 0;
50252   }
50253   arg2 = *argp2;
50254   arg3 = (Dali::TouchData *)jarg3;
50255   if (!arg3) {
50256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50257     return 0;
50258   }
50259   {
50260     try {
50261       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50262     } catch (std::out_of_range& e) {
50263       {
50264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50265       };
50266     } catch (std::exception& e) {
50267       {
50268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50269       };
50270     } catch (...) {
50271       {
50272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50273       };
50274     }
50275   }
50276   jresult = result;
50277   return jresult;
50278 }
50279
50280
50281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50282   void * jresult ;
50283   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50284
50285   {
50286     try {
50287       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50288     } catch (std::out_of_range& e) {
50289       {
50290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (std::exception& e) {
50293       {
50294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50295       };
50296     } catch (...) {
50297       {
50298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50299       };
50300     }
50301   }
50302   jresult = (void *)result;
50303   return jresult;
50304 }
50305
50306
50307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50308   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50309
50310   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50311   {
50312     try {
50313       delete arg1;
50314     } catch (std::out_of_range& e) {
50315       {
50316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50317       };
50318     } catch (std::exception& e) {
50319       {
50320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50321       };
50322     } catch (...) {
50323       {
50324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50325       };
50326     }
50327   }
50328 }
50329
50330
50331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50332   unsigned int jresult ;
50333   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50334   bool result;
50335
50336   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50337   {
50338     try {
50339       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);
50340     } catch (std::out_of_range& e) {
50341       {
50342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50343       };
50344     } catch (std::exception& e) {
50345       {
50346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50347       };
50348     } catch (...) {
50349       {
50350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50351       };
50352     }
50353   }
50354   jresult = result;
50355   return jresult;
50356 }
50357
50358
50359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50360   unsigned long jresult ;
50361   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50362   std::size_t result;
50363
50364   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50365   {
50366     try {
50367       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);
50368     } catch (std::out_of_range& e) {
50369       {
50370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50371       };
50372     } catch (std::exception& e) {
50373       {
50374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50375       };
50376     } catch (...) {
50377       {
50378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50379       };
50380     }
50381   }
50382   jresult = (unsigned long)result;
50383   return jresult;
50384 }
50385
50386
50387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50388   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50389   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50390
50391   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50392   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50393   {
50394     try {
50395       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50396     } catch (std::out_of_range& e) {
50397       {
50398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50399       };
50400     } catch (std::exception& e) {
50401       {
50402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50403       };
50404     } catch (...) {
50405       {
50406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50407       };
50408     }
50409   }
50410 }
50411
50412
50413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50414   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50415   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50416
50417   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50418   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50419   {
50420     try {
50421       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50422     } catch (std::out_of_range& e) {
50423       {
50424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50425       };
50426     } catch (std::exception& e) {
50427       {
50428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50429       };
50430     } catch (...) {
50431       {
50432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50433       };
50434     }
50435   }
50436 }
50437
50438
50439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50440   unsigned int jresult ;
50441   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50442   Dali::Actor arg2 ;
50443   Dali::HoverEvent *arg3 = 0 ;
50444   Dali::Actor *argp2 ;
50445   bool result;
50446
50447   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50448   argp2 = (Dali::Actor *)jarg2;
50449   if (!argp2) {
50450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50451     return 0;
50452   }
50453   arg2 = *argp2;
50454   arg3 = (Dali::HoverEvent *)jarg3;
50455   if (!arg3) {
50456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50457     return 0;
50458   }
50459   {
50460     try {
50461       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50462     } catch (std::out_of_range& e) {
50463       {
50464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (std::exception& e) {
50467       {
50468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50469       };
50470     } catch (...) {
50471       {
50472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50473       };
50474     }
50475   }
50476   jresult = result;
50477   return jresult;
50478 }
50479
50480
50481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50482   void * jresult ;
50483   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50484
50485   {
50486     try {
50487       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50488     } catch (std::out_of_range& e) {
50489       {
50490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (std::exception& e) {
50493       {
50494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (...) {
50497       {
50498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50499       };
50500     }
50501   }
50502   jresult = (void *)result;
50503   return jresult;
50504 }
50505
50506
50507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50508   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50509
50510   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50511   {
50512     try {
50513       delete arg1;
50514     } catch (std::out_of_range& e) {
50515       {
50516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50517       };
50518     } catch (std::exception& e) {
50519       {
50520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50521       };
50522     } catch (...) {
50523       {
50524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50525       };
50526     }
50527   }
50528 }
50529
50530
50531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50532   unsigned int jresult ;
50533   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50534   bool result;
50535
50536   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50537   {
50538     try {
50539       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);
50540     } catch (std::out_of_range& e) {
50541       {
50542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50543       };
50544     } catch (std::exception& e) {
50545       {
50546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50547       };
50548     } catch (...) {
50549       {
50550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50551       };
50552     }
50553   }
50554   jresult = result;
50555   return jresult;
50556 }
50557
50558
50559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50560   unsigned long jresult ;
50561   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50562   std::size_t result;
50563
50564   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50565   {
50566     try {
50567       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);
50568     } catch (std::out_of_range& e) {
50569       {
50570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50571       };
50572     } catch (std::exception& e) {
50573       {
50574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50575       };
50576     } catch (...) {
50577       {
50578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50579       };
50580     }
50581   }
50582   jresult = (unsigned long)result;
50583   return jresult;
50584 }
50585
50586
50587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50588   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50589   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50590
50591   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50592   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50593   {
50594     try {
50595       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50596     } catch (std::out_of_range& e) {
50597       {
50598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50599       };
50600     } catch (std::exception& e) {
50601       {
50602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50603       };
50604     } catch (...) {
50605       {
50606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50607       };
50608     }
50609   }
50610 }
50611
50612
50613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50614   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50615   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50616
50617   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50618   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50619   {
50620     try {
50621       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50622     } catch (std::out_of_range& e) {
50623       {
50624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50625       };
50626     } catch (std::exception& e) {
50627       {
50628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50629       };
50630     } catch (...) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50633       };
50634     }
50635   }
50636 }
50637
50638
50639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50640   unsigned int jresult ;
50641   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50642   Dali::Actor arg2 ;
50643   Dali::WheelEvent *arg3 = 0 ;
50644   Dali::Actor *argp2 ;
50645   bool result;
50646
50647   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50648   argp2 = (Dali::Actor *)jarg2;
50649   if (!argp2) {
50650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50651     return 0;
50652   }
50653   arg2 = *argp2;
50654   arg3 = (Dali::WheelEvent *)jarg3;
50655   if (!arg3) {
50656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50657     return 0;
50658   }
50659   {
50660     try {
50661       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50662     } catch (std::out_of_range& e) {
50663       {
50664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50665       };
50666     } catch (std::exception& e) {
50667       {
50668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50669       };
50670     } catch (...) {
50671       {
50672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50673       };
50674     }
50675   }
50676   jresult = result;
50677   return jresult;
50678 }
50679
50680
50681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50682   void * jresult ;
50683   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50684
50685   {
50686     try {
50687       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50688     } catch (std::out_of_range& e) {
50689       {
50690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (std::exception& e) {
50693       {
50694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50695       };
50696     } catch (...) {
50697       {
50698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50699       };
50700     }
50701   }
50702   jresult = (void *)result;
50703   return jresult;
50704 }
50705
50706
50707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50708   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50709
50710   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50711   {
50712     try {
50713       delete arg1;
50714     } catch (std::out_of_range& e) {
50715       {
50716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50717       };
50718     } catch (std::exception& e) {
50719       {
50720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50721       };
50722     } catch (...) {
50723       {
50724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50725       };
50726     }
50727   }
50728 }
50729
50730
50731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50732   unsigned int jresult ;
50733   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50734   bool result;
50735
50736   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50737   {
50738     try {
50739       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50740     } catch (std::out_of_range& e) {
50741       {
50742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50743       };
50744     } catch (std::exception& e) {
50745       {
50746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50747       };
50748     } catch (...) {
50749       {
50750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50751       };
50752     }
50753   }
50754   jresult = result;
50755   return jresult;
50756 }
50757
50758
50759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50760   unsigned long jresult ;
50761   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50762   std::size_t result;
50763
50764   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50765   {
50766     try {
50767       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50768     } catch (std::out_of_range& e) {
50769       {
50770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50771       };
50772     } catch (std::exception& e) {
50773       {
50774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50775       };
50776     } catch (...) {
50777       {
50778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50779       };
50780     }
50781   }
50782   jresult = (unsigned long)result;
50783   return jresult;
50784 }
50785
50786
50787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50788   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50789   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50790
50791   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50792   arg2 = (void (*)(Dali::Actor))jarg2;
50793   {
50794     try {
50795       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50796     } catch (std::out_of_range& e) {
50797       {
50798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50799       };
50800     } catch (std::exception& e) {
50801       {
50802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50803       };
50804     } catch (...) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50807       };
50808     }
50809   }
50810 }
50811
50812
50813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50814   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50815   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50816
50817   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50818   arg2 = (void (*)(Dali::Actor))jarg2;
50819   {
50820     try {
50821       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50822     } catch (std::out_of_range& e) {
50823       {
50824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50825       };
50826     } catch (std::exception& e) {
50827       {
50828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50829       };
50830     } catch (...) {
50831       {
50832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50833       };
50834     }
50835   }
50836 }
50837
50838
50839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50840   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50841   Dali::Actor arg2 ;
50842   Dali::Actor *argp2 ;
50843
50844   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50845   argp2 = (Dali::Actor *)jarg2;
50846   if (!argp2) {
50847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50848     return ;
50849   }
50850   arg2 = *argp2;
50851   {
50852     try {
50853       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50854     } catch (std::out_of_range& e) {
50855       {
50856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50857       };
50858     } catch (std::exception& e) {
50859       {
50860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50861       };
50862     } catch (...) {
50863       {
50864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50865       };
50866     }
50867   }
50868 }
50869
50870
50871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50872   void * jresult ;
50873   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50874
50875   {
50876     try {
50877       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50878     } catch (std::out_of_range& e) {
50879       {
50880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50881       };
50882     } catch (std::exception& e) {
50883       {
50884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50885       };
50886     } catch (...) {
50887       {
50888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50889       };
50890     }
50891   }
50892   jresult = (void *)result;
50893   return jresult;
50894 }
50895
50896
50897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50898   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50899
50900   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50901   {
50902     try {
50903       delete arg1;
50904     } catch (std::out_of_range& e) {
50905       {
50906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50907       };
50908     } catch (std::exception& e) {
50909       {
50910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50911       };
50912     } catch (...) {
50913       {
50914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50915       };
50916     }
50917   }
50918 }
50919
50920
50921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50922   unsigned int jresult ;
50923   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50924   bool result;
50925
50926   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50927   {
50928     try {
50929       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50930     } catch (std::out_of_range& e) {
50931       {
50932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50933       };
50934     } catch (std::exception& e) {
50935       {
50936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50937       };
50938     } catch (...) {
50939       {
50940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50941       };
50942     }
50943   }
50944   jresult = result;
50945   return jresult;
50946 }
50947
50948
50949 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50950   unsigned long jresult ;
50951   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50952   std::size_t result;
50953
50954   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50955   {
50956     try {
50957       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50958     } catch (std::out_of_range& e) {
50959       {
50960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50961       };
50962     } catch (std::exception& e) {
50963       {
50964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50965       };
50966     } catch (...) {
50967       {
50968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50969       };
50970     }
50971   }
50972   jresult = (unsigned long)result;
50973   return jresult;
50974 }
50975
50976
50977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50978   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50979   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50980
50981   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50982   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50983   {
50984     try {
50985       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50986     } catch (std::out_of_range& e) {
50987       {
50988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50989       };
50990     } catch (std::exception& e) {
50991       {
50992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50993       };
50994     } catch (...) {
50995       {
50996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50997       };
50998     }
50999   }
51000 }
51001
51002
51003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51004   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51005   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51006
51007   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51008   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51009   {
51010     try {
51011       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51012     } catch (std::out_of_range& e) {
51013       {
51014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51015       };
51016     } catch (std::exception& e) {
51017       {
51018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51019       };
51020     } catch (...) {
51021       {
51022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51023       };
51024     }
51025   }
51026 }
51027
51028
51029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51030   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51031   Dali::KeyEvent *arg2 = 0 ;
51032
51033   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51034   arg2 = (Dali::KeyEvent *)jarg2;
51035   if (!arg2) {
51036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51037     return ;
51038   }
51039   {
51040     try {
51041       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51042     } catch (std::out_of_range& e) {
51043       {
51044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51045       };
51046     } catch (std::exception& e) {
51047       {
51048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51049       };
51050     } catch (...) {
51051       {
51052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51053       };
51054     }
51055   }
51056 }
51057
51058
51059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51060   void * jresult ;
51061   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51062
51063   {
51064     try {
51065       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51066     } catch (std::out_of_range& e) {
51067       {
51068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51069       };
51070     } catch (std::exception& e) {
51071       {
51072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51073       };
51074     } catch (...) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51077       };
51078     }
51079   }
51080   jresult = (void *)result;
51081   return jresult;
51082 }
51083
51084
51085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51086   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51087
51088   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51089   {
51090     try {
51091       delete arg1;
51092     } catch (std::out_of_range& e) {
51093       {
51094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (std::exception& e) {
51097       {
51098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51099       };
51100     } catch (...) {
51101       {
51102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51103       };
51104     }
51105   }
51106 }
51107
51108
51109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51110   unsigned int jresult ;
51111   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51112   bool result;
51113
51114   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51115   {
51116     try {
51117       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51118     } catch (std::out_of_range& e) {
51119       {
51120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51121       };
51122     } catch (std::exception& e) {
51123       {
51124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51125       };
51126     } catch (...) {
51127       {
51128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51129       };
51130     }
51131   }
51132   jresult = result;
51133   return jresult;
51134 }
51135
51136
51137 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51138   unsigned long jresult ;
51139   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51140   std::size_t result;
51141
51142   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51143   {
51144     try {
51145       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51146     } catch (std::out_of_range& e) {
51147       {
51148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51149       };
51150     } catch (std::exception& e) {
51151       {
51152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51153       };
51154     } catch (...) {
51155       {
51156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51157       };
51158     }
51159   }
51160   jresult = (unsigned long)result;
51161   return jresult;
51162 }
51163
51164
51165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51166   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51167   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51168
51169   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51170   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51171   {
51172     try {
51173       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51174     } catch (std::out_of_range& e) {
51175       {
51176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51177       };
51178     } catch (std::exception& e) {
51179       {
51180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51181       };
51182     } catch (...) {
51183       {
51184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51185       };
51186     }
51187   }
51188 }
51189
51190
51191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51192   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51193   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51194
51195   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51196   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51197   {
51198     try {
51199       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51200     } catch (std::out_of_range& e) {
51201       {
51202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (std::exception& e) {
51205       {
51206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51207       };
51208     } catch (...) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51211       };
51212     }
51213   }
51214 }
51215
51216
51217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51218   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51219   Dali::TouchData *arg2 = 0 ;
51220
51221   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51222   arg2 = (Dali::TouchData *)jarg2;
51223   if (!arg2) {
51224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51225     return ;
51226   }
51227   {
51228     try {
51229       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51230     } catch (std::out_of_range& e) {
51231       {
51232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51233       };
51234     } catch (std::exception& e) {
51235       {
51236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51237       };
51238     } catch (...) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51241       };
51242     }
51243   }
51244 }
51245
51246
51247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51248   void * jresult ;
51249   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51250
51251   {
51252     try {
51253       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51254     } catch (std::out_of_range& e) {
51255       {
51256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51257       };
51258     } catch (std::exception& e) {
51259       {
51260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51261       };
51262     } catch (...) {
51263       {
51264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51265       };
51266     }
51267   }
51268   jresult = (void *)result;
51269   return jresult;
51270 }
51271
51272
51273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51274   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51275
51276   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51277   {
51278     try {
51279       delete arg1;
51280     } catch (std::out_of_range& e) {
51281       {
51282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (std::exception& e) {
51285       {
51286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51287       };
51288     } catch (...) {
51289       {
51290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51291       };
51292     }
51293   }
51294 }
51295
51296
51297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51298   unsigned int jresult ;
51299   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51300   bool result;
51301
51302   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51303   {
51304     try {
51305       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51306     } catch (std::out_of_range& e) {
51307       {
51308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51309       };
51310     } catch (std::exception& e) {
51311       {
51312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51313       };
51314     } catch (...) {
51315       {
51316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51317       };
51318     }
51319   }
51320   jresult = result;
51321   return jresult;
51322 }
51323
51324
51325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51326   unsigned long jresult ;
51327   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51328   std::size_t result;
51329
51330   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51331   {
51332     try {
51333       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51334     } catch (std::out_of_range& e) {
51335       {
51336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51337       };
51338     } catch (std::exception& e) {
51339       {
51340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (...) {
51343       {
51344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51345       };
51346     }
51347   }
51348   jresult = (unsigned long)result;
51349   return jresult;
51350 }
51351
51352
51353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51354   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51355   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51356
51357   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51358   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51359   {
51360     try {
51361       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51362     } catch (std::out_of_range& e) {
51363       {
51364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (std::exception& e) {
51367       {
51368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51369       };
51370     } catch (...) {
51371       {
51372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51373       };
51374     }
51375   }
51376 }
51377
51378
51379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51380   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51381   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51382
51383   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51384   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51385   {
51386     try {
51387       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51388     } catch (std::out_of_range& e) {
51389       {
51390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51391       };
51392     } catch (std::exception& e) {
51393       {
51394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51395       };
51396     } catch (...) {
51397       {
51398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51399       };
51400     }
51401   }
51402 }
51403
51404
51405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51406   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51407   Dali::WheelEvent *arg2 = 0 ;
51408
51409   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51410   arg2 = (Dali::WheelEvent *)jarg2;
51411   if (!arg2) {
51412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51413     return ;
51414   }
51415   {
51416     try {
51417       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51418     } catch (std::out_of_range& e) {
51419       {
51420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (std::exception& e) {
51423       {
51424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51425       };
51426     } catch (...) {
51427       {
51428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51429       };
51430     }
51431   }
51432 }
51433
51434
51435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51436   void * jresult ;
51437   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51438
51439   {
51440     try {
51441       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51442     } catch (std::out_of_range& e) {
51443       {
51444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51445       };
51446     } catch (std::exception& e) {
51447       {
51448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51453       };
51454     }
51455   }
51456   jresult = (void *)result;
51457   return jresult;
51458 }
51459
51460
51461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51462   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51463
51464   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51465   {
51466     try {
51467       delete arg1;
51468     } catch (std::out_of_range& e) {
51469       {
51470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51471       };
51472     } catch (std::exception& e) {
51473       {
51474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51475       };
51476     } catch (...) {
51477       {
51478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51479       };
51480     }
51481   }
51482 }
51483
51484
51485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51486   void * jresult ;
51487   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51488
51489   {
51490     try {
51491       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51492     } catch (std::out_of_range& e) {
51493       {
51494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51495       };
51496     } catch (std::exception& e) {
51497       {
51498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51499       };
51500     } catch (...) {
51501       {
51502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51503       };
51504     }
51505   }
51506   jresult = (void *)result;
51507   return jresult;
51508 }
51509
51510
51511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51512   void * jresult ;
51513   Dali::Radian arg1 ;
51514   Dali::Radian arg2 ;
51515   Dali::Radian *argp1 ;
51516   Dali::Radian *argp2 ;
51517   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51518
51519   argp1 = (Dali::Radian *)jarg1;
51520   if (!argp1) {
51521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51522     return 0;
51523   }
51524   arg1 = *argp1;
51525   argp2 = (Dali::Radian *)jarg2;
51526   if (!argp2) {
51527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51528     return 0;
51529   }
51530   arg2 = *argp2;
51531   {
51532     try {
51533       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51534     } catch (std::out_of_range& e) {
51535       {
51536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51537       };
51538     } catch (std::exception& e) {
51539       {
51540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51541       };
51542     } catch (...) {
51543       {
51544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51545       };
51546     }
51547   }
51548   jresult = (void *)result;
51549   return jresult;
51550 }
51551
51552
51553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51554   void * jresult ;
51555   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51556   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51557
51558   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51559   if (!arg1) {
51560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51561     return 0;
51562   }
51563   {
51564     try {
51565       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51566     } catch (std::out_of_range& e) {
51567       {
51568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (std::exception& e) {
51571       {
51572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51573       };
51574     } catch (...) {
51575       {
51576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51577       };
51578     }
51579   }
51580   jresult = (void *)result;
51581   return jresult;
51582 }
51583
51584
51585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51586   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51587   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51588
51589   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51590   arg2 = (Dali::Radian *)jarg2;
51591   if (arg1) (arg1)->first = *arg2;
51592 }
51593
51594
51595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51596   void * jresult ;
51597   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51598   Dali::Radian *result = 0 ;
51599
51600   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51601   result = (Dali::Radian *)& ((arg1)->first);
51602   jresult = (void *)result;
51603   return jresult;
51604 }
51605
51606
51607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51608   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51609   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51610
51611   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51612   arg2 = (Dali::Radian *)jarg2;
51613   if (arg1) (arg1)->second = *arg2;
51614 }
51615
51616
51617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51618   void * jresult ;
51619   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51620   Dali::Radian *result = 0 ;
51621
51622   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51623   result = (Dali::Radian *)& ((arg1)->second);
51624   jresult = (void *)result;
51625   return jresult;
51626 }
51627
51628
51629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51630   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51631
51632   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51633   {
51634     try {
51635       delete arg1;
51636     } catch (std::out_of_range& e) {
51637       {
51638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51639       };
51640     } catch (std::exception& e) {
51641       {
51642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51643       };
51644     } catch (...) {
51645       {
51646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51647       };
51648     }
51649   }
51650 }
51651
51652
51653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51654   unsigned int jresult ;
51655   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51656   bool result;
51657
51658   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51659   {
51660     try {
51661       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);
51662     } catch (std::out_of_range& e) {
51663       {
51664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51665       };
51666     } catch (std::exception& e) {
51667       {
51668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51669       };
51670     } catch (...) {
51671       {
51672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51673       };
51674     }
51675   }
51676   jresult = result;
51677   return jresult;
51678 }
51679
51680
51681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51682   unsigned long jresult ;
51683   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51684   std::size_t result;
51685
51686   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51687   {
51688     try {
51689       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);
51690     } catch (std::out_of_range& e) {
51691       {
51692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51693       };
51694     } catch (std::exception& e) {
51695       {
51696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51697       };
51698     } catch (...) {
51699       {
51700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51701       };
51702     }
51703   }
51704   jresult = (unsigned long)result;
51705   return jresult;
51706 }
51707
51708
51709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51710   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51711   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51712
51713   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51714   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51715   {
51716     try {
51717       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51718     } catch (std::out_of_range& e) {
51719       {
51720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (std::exception& e) {
51723       {
51724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51725       };
51726     } catch (...) {
51727       {
51728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51729       };
51730     }
51731   }
51732 }
51733
51734
51735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51736   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51737   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51738
51739   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51740   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51741   {
51742     try {
51743       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51744     } catch (std::out_of_range& e) {
51745       {
51746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (std::exception& e) {
51749       {
51750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51751       };
51752     } catch (...) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51755       };
51756     }
51757   }
51758 }
51759
51760
51761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51762   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51763   Dali::Actor arg2 ;
51764   Dali::PanGesture *arg3 = 0 ;
51765   Dali::Actor *argp2 ;
51766
51767   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51768   argp2 = (Dali::Actor *)jarg2;
51769   if (!argp2) {
51770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51771     return ;
51772   }
51773   arg2 = *argp2;
51774   arg3 = (Dali::PanGesture *)jarg3;
51775   if (!arg3) {
51776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51777     return ;
51778   }
51779   {
51780     try {
51781       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51782     } catch (std::out_of_range& e) {
51783       {
51784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51785       };
51786     } catch (std::exception& e) {
51787       {
51788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51793       };
51794     }
51795   }
51796 }
51797
51798
51799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51800   void * jresult ;
51801   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51802
51803   {
51804     try {
51805       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51806     } catch (std::out_of_range& e) {
51807       {
51808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51809       };
51810     } catch (std::exception& e) {
51811       {
51812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51813       };
51814     } catch (...) {
51815       {
51816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51817       };
51818     }
51819   }
51820   jresult = (void *)result;
51821   return jresult;
51822 }
51823
51824
51825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51826   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51827
51828   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51829   {
51830     try {
51831       delete arg1;
51832     } catch (std::out_of_range& e) {
51833       {
51834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (std::exception& e) {
51837       {
51838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51843       };
51844     }
51845   }
51846 }
51847
51848
51849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51850   unsigned int jresult ;
51851   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51852   bool result;
51853
51854   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51855   {
51856     try {
51857       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);
51858     } catch (std::out_of_range& e) {
51859       {
51860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51861       };
51862     } catch (std::exception& e) {
51863       {
51864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51865       };
51866     } catch (...) {
51867       {
51868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51869       };
51870     }
51871   }
51872   jresult = result;
51873   return jresult;
51874 }
51875
51876
51877 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51878   unsigned long jresult ;
51879   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51880   std::size_t result;
51881
51882   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51883   {
51884     try {
51885       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);
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (...) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51897       };
51898     }
51899   }
51900   jresult = (unsigned long)result;
51901   return jresult;
51902 }
51903
51904
51905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51906   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51907   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51908
51909   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51910   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51911   {
51912     try {
51913       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51921       };
51922     } catch (...) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51925       };
51926     }
51927   }
51928 }
51929
51930
51931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51932   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51933   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51934
51935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51936   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51937   {
51938     try {
51939       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51940     } catch (std::out_of_range& e) {
51941       {
51942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51943       };
51944     } catch (std::exception& e) {
51945       {
51946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51947       };
51948     } catch (...) {
51949       {
51950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51951       };
51952     }
51953   }
51954 }
51955
51956
51957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51959   Dali::Actor arg2 ;
51960   Dali::PinchGesture *arg3 = 0 ;
51961   Dali::Actor *argp2 ;
51962
51963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51964   argp2 = (Dali::Actor *)jarg2;
51965   if (!argp2) {
51966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51967     return ;
51968   }
51969   arg2 = *argp2;
51970   arg3 = (Dali::PinchGesture *)jarg3;
51971   if (!arg3) {
51972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51973     return ;
51974   }
51975   {
51976     try {
51977       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51978     } catch (std::out_of_range& e) {
51979       {
51980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51981       };
51982     } catch (std::exception& e) {
51983       {
51984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51985       };
51986     } catch (...) {
51987       {
51988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51989       };
51990     }
51991   }
51992 }
51993
51994
51995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51996   void * jresult ;
51997   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51998
51999   {
52000     try {
52001       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
52002     } catch (std::out_of_range& e) {
52003       {
52004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52005       };
52006     } catch (std::exception& e) {
52007       {
52008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52009       };
52010     } catch (...) {
52011       {
52012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52013       };
52014     }
52015   }
52016   jresult = (void *)result;
52017   return jresult;
52018 }
52019
52020
52021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52022   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52023
52024   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52025   {
52026     try {
52027       delete arg1;
52028     } catch (std::out_of_range& e) {
52029       {
52030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (std::exception& e) {
52033       {
52034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52035       };
52036     } catch (...) {
52037       {
52038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52039       };
52040     }
52041   }
52042 }
52043
52044
52045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52046   unsigned int jresult ;
52047   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52048   bool result;
52049
52050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52051   {
52052     try {
52053       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);
52054     } catch (std::out_of_range& e) {
52055       {
52056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52057       };
52058     } catch (std::exception& e) {
52059       {
52060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52061       };
52062     } catch (...) {
52063       {
52064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52065       };
52066     }
52067   }
52068   jresult = result;
52069   return jresult;
52070 }
52071
52072
52073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52074   unsigned long jresult ;
52075   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52076   std::size_t result;
52077
52078   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52079   {
52080     try {
52081       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);
52082     } catch (std::out_of_range& e) {
52083       {
52084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52085       };
52086     } catch (std::exception& e) {
52087       {
52088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52089       };
52090     } catch (...) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52093       };
52094     }
52095   }
52096   jresult = (unsigned long)result;
52097   return jresult;
52098 }
52099
52100
52101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52102   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52103   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52104
52105   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52106   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52107   {
52108     try {
52109       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52110     } catch (std::out_of_range& e) {
52111       {
52112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (std::exception& e) {
52115       {
52116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52117       };
52118     } catch (...) {
52119       {
52120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52121       };
52122     }
52123   }
52124 }
52125
52126
52127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52128   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52129   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52130
52131   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52132   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52133   {
52134     try {
52135       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52136     } catch (std::out_of_range& e) {
52137       {
52138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52139       };
52140     } catch (std::exception& e) {
52141       {
52142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52143       };
52144     } catch (...) {
52145       {
52146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52147       };
52148     }
52149   }
52150 }
52151
52152
52153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52154   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52155   Dali::Actor arg2 ;
52156   Dali::TapGesture *arg3 = 0 ;
52157   Dali::Actor *argp2 ;
52158
52159   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52160   argp2 = (Dali::Actor *)jarg2;
52161   if (!argp2) {
52162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52163     return ;
52164   }
52165   arg2 = *argp2;
52166   arg3 = (Dali::TapGesture *)jarg3;
52167   if (!arg3) {
52168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52169     return ;
52170   }
52171   {
52172     try {
52173       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52174     } catch (std::out_of_range& e) {
52175       {
52176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52177       };
52178     } catch (std::exception& e) {
52179       {
52180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52181       };
52182     } catch (...) {
52183       {
52184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52185       };
52186     }
52187   }
52188 }
52189
52190
52191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52192   void * jresult ;
52193   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52194
52195   {
52196     try {
52197       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52198     } catch (std::out_of_range& e) {
52199       {
52200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52201       };
52202     } catch (std::exception& e) {
52203       {
52204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52205       };
52206     } catch (...) {
52207       {
52208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52209       };
52210     }
52211   }
52212   jresult = (void *)result;
52213   return jresult;
52214 }
52215
52216
52217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52218   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52219
52220   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52221   {
52222     try {
52223       delete arg1;
52224     } catch (std::out_of_range& e) {
52225       {
52226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (std::exception& e) {
52229       {
52230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (...) {
52233       {
52234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52235       };
52236     }
52237   }
52238 }
52239
52240
52241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52242   unsigned int jresult ;
52243   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52244   bool result;
52245
52246   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52247   {
52248     try {
52249       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52250     } catch (std::out_of_range& e) {
52251       {
52252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (std::exception& e) {
52255       {
52256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52257       };
52258     } catch (...) {
52259       {
52260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52261       };
52262     }
52263   }
52264   jresult = result;
52265   return jresult;
52266 }
52267
52268
52269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52270   unsigned long jresult ;
52271   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52272   std::size_t result;
52273
52274   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52275   {
52276     try {
52277       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52278     } catch (std::out_of_range& e) {
52279       {
52280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52281       };
52282     } catch (std::exception& e) {
52283       {
52284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52285       };
52286     } catch (...) {
52287       {
52288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52289       };
52290     }
52291   }
52292   jresult = (unsigned long)result;
52293   return jresult;
52294 }
52295
52296
52297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52298   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52299   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52300
52301   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52302   arg2 = (void (*)(Dali::Animation &))jarg2;
52303   {
52304     try {
52305       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52306     } catch (std::out_of_range& e) {
52307       {
52308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52309       };
52310     } catch (std::exception& e) {
52311       {
52312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52313       };
52314     } catch (...) {
52315       {
52316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52317       };
52318     }
52319   }
52320 }
52321
52322
52323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52324   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52325   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52326
52327   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52328   arg2 = (void (*)(Dali::Animation &))jarg2;
52329   {
52330     try {
52331       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52332     } catch (std::out_of_range& e) {
52333       {
52334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52335       };
52336     } catch (std::exception& e) {
52337       {
52338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52339       };
52340     } catch (...) {
52341       {
52342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52343       };
52344     }
52345   }
52346 }
52347
52348
52349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52350   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52351   Dali::Animation *arg2 = 0 ;
52352
52353   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52354   arg2 = (Dali::Animation *)jarg2;
52355   if (!arg2) {
52356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52357     return ;
52358   }
52359   {
52360     try {
52361       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52362     } catch (std::out_of_range& e) {
52363       {
52364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (std::exception& e) {
52367       {
52368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52369       };
52370     } catch (...) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52373       };
52374     }
52375   }
52376 }
52377
52378
52379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52380   void * jresult ;
52381   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52382
52383   {
52384     try {
52385       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52386     } catch (std::out_of_range& e) {
52387       {
52388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (std::exception& e) {
52391       {
52392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52393       };
52394     } catch (...) {
52395       {
52396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52397       };
52398     }
52399   }
52400   jresult = (void *)result;
52401   return jresult;
52402 }
52403
52404
52405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52406   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52407
52408   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52409   {
52410     try {
52411       delete arg1;
52412     } catch (std::out_of_range& e) {
52413       {
52414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52415       };
52416     } catch (std::exception& e) {
52417       {
52418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52419       };
52420     } catch (...) {
52421       {
52422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52423       };
52424     }
52425   }
52426 }
52427
52428
52429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52430   unsigned int jresult ;
52431   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52432   bool result;
52433
52434   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52435   {
52436     try {
52437       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52438     } catch (std::out_of_range& e) {
52439       {
52440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (std::exception& e) {
52443       {
52444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52445       };
52446     } catch (...) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52449       };
52450     }
52451   }
52452   jresult = result;
52453   return jresult;
52454 }
52455
52456
52457 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52458   unsigned long jresult ;
52459   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52460   std::size_t result;
52461
52462   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52463   {
52464     try {
52465       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52466     } catch (std::out_of_range& e) {
52467       {
52468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52469       };
52470     } catch (std::exception& e) {
52471       {
52472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52473       };
52474     } catch (...) {
52475       {
52476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52477       };
52478     }
52479   }
52480   jresult = (unsigned long)result;
52481   return jresult;
52482 }
52483
52484
52485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52486   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52487   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52488
52489   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52490   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52491   {
52492     try {
52493       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52494     } catch (std::out_of_range& e) {
52495       {
52496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52497       };
52498     } catch (std::exception& e) {
52499       {
52500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52501       };
52502     } catch (...) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52505       };
52506     }
52507   }
52508 }
52509
52510
52511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52512   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52513   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52514
52515   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52516   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52517   {
52518     try {
52519       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52520     } catch (std::out_of_range& e) {
52521       {
52522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (std::exception& e) {
52525       {
52526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52531       };
52532     }
52533   }
52534 }
52535
52536
52537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52538   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52539   Dali::ResourceImage arg2 ;
52540   Dali::ResourceImage *argp2 ;
52541
52542   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52543   argp2 = (Dali::ResourceImage *)jarg2;
52544   if (!argp2) {
52545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52546     return ;
52547   }
52548   arg2 = *argp2;
52549   {
52550     try {
52551       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52552     } catch (std::out_of_range& e) {
52553       {
52554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52555       };
52556     } catch (std::exception& e) {
52557       {
52558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52559       };
52560     } catch (...) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52563       };
52564     }
52565   }
52566 }
52567
52568
52569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52570   void * jresult ;
52571   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52572
52573   {
52574     try {
52575       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52576     } catch (std::out_of_range& e) {
52577       {
52578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (std::exception& e) {
52581       {
52582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52583       };
52584     } catch (...) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52587       };
52588     }
52589   }
52590   jresult = (void *)result;
52591   return jresult;
52592 }
52593
52594
52595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52596   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52597
52598   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52599   {
52600     try {
52601       delete arg1;
52602     } catch (std::out_of_range& e) {
52603       {
52604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52605       };
52606     } catch (std::exception& e) {
52607       {
52608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52609       };
52610     } catch (...) {
52611       {
52612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52613       };
52614     }
52615   }
52616 }
52617
52618
52619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52620   unsigned int jresult ;
52621   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52622   bool result;
52623
52624   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52625   {
52626     try {
52627       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);
52628     } catch (std::out_of_range& e) {
52629       {
52630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (std::exception& e) {
52633       {
52634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52635       };
52636     } catch (...) {
52637       {
52638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52639       };
52640     }
52641   }
52642   jresult = result;
52643   return jresult;
52644 }
52645
52646
52647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52648   unsigned long jresult ;
52649   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52650   std::size_t result;
52651
52652   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52653   {
52654     try {
52655       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);
52656     } catch (std::out_of_range& e) {
52657       {
52658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52659       };
52660     } catch (std::exception& e) {
52661       {
52662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52667       };
52668     }
52669   }
52670   jresult = (unsigned long)result;
52671   return jresult;
52672 }
52673
52674
52675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52676   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52677   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52678
52679   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52680   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52681   {
52682     try {
52683       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52684     } catch (std::out_of_range& e) {
52685       {
52686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52687       };
52688     } catch (std::exception& e) {
52689       {
52690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52691       };
52692     } catch (...) {
52693       {
52694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52695       };
52696     }
52697   }
52698 }
52699
52700
52701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52702   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52703   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52704
52705   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52706   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52707   {
52708     try {
52709       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52710     } catch (std::out_of_range& e) {
52711       {
52712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (std::exception& e) {
52715       {
52716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52717       };
52718     } catch (...) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52721       };
52722     }
52723   }
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52728   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52729   Dali::Actor arg2 ;
52730   bool arg3 ;
52731   Dali::DevelActor::VisibilityChange::Type arg4 ;
52732   Dali::Actor *argp2 ;
52733
52734   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52735   argp2 = (Dali::Actor *)jarg2;
52736   if (!argp2) {
52737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52738     return ;
52739   }
52740   arg2 = *argp2;
52741   arg3 = jarg3 ? true : false;
52742   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52743   {
52744     try {
52745       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52746     } catch (std::out_of_range& e) {
52747       {
52748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52749       };
52750     } catch (std::exception& e) {
52751       {
52752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52753       };
52754     } catch (...) {
52755       {
52756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52757       };
52758     }
52759   }
52760 }
52761
52762
52763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52764   void * jresult ;
52765   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52766
52767   {
52768     try {
52769       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52770     } catch (std::out_of_range& e) {
52771       {
52772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (std::exception& e) {
52775       {
52776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52777       };
52778     } catch (...) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52781       };
52782     }
52783   }
52784   jresult = (void *)result;
52785   return jresult;
52786 }
52787
52788
52789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52790   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52791
52792   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52793   {
52794     try {
52795       delete arg1;
52796     } catch (std::out_of_range& e) {
52797       {
52798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52799       };
52800     } catch (std::exception& e) {
52801       {
52802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52803       };
52804     } catch (...) {
52805       {
52806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52807       };
52808     }
52809   }
52810 }
52811
52812
52813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52814   void * jresult ;
52815   Dali::Timer *result = 0 ;
52816
52817   {
52818     try {
52819       result = (Dali::Timer *)new Dali::Timer();
52820     } catch (std::out_of_range& e) {
52821       {
52822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52823       };
52824     } catch (std::exception& e) {
52825       {
52826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52827       };
52828     } catch (...) {
52829       {
52830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52831       };
52832     }
52833   }
52834   jresult = (void *)result;
52835   return jresult;
52836 }
52837
52838
52839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52840   void * jresult ;
52841   unsigned int arg1 ;
52842   Dali::Timer result;
52843
52844   arg1 = (unsigned int)jarg1;
52845   {
52846     try {
52847       result = Dali::Timer::New(arg1);
52848     } catch (std::out_of_range& e) {
52849       {
52850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52851       };
52852     } catch (std::exception& e) {
52853       {
52854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52855       };
52856     } catch (...) {
52857       {
52858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52859       };
52860     }
52861   }
52862   jresult = new Dali::Timer((const Dali::Timer &)result);
52863   return jresult;
52864 }
52865
52866
52867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52868   void * jresult ;
52869   Dali::Timer *arg1 = 0 ;
52870   Dali::Timer *result = 0 ;
52871
52872   arg1 = (Dali::Timer *)jarg1;
52873   if (!arg1) {
52874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52875     return 0;
52876   }
52877   {
52878     try {
52879       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52880     } catch (std::out_of_range& e) {
52881       {
52882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52883       };
52884     } catch (std::exception& e) {
52885       {
52886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52887       };
52888     } catch (...) {
52889       {
52890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52891       };
52892     }
52893   }
52894   jresult = (void *)result;
52895   return jresult;
52896 }
52897
52898
52899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52900   void * jresult ;
52901   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52902   Dali::Timer *arg2 = 0 ;
52903   Dali::Timer *result = 0 ;
52904
52905   arg1 = (Dali::Timer *)jarg1;
52906   arg2 = (Dali::Timer *)jarg2;
52907   if (!arg2) {
52908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52909     return 0;
52910   }
52911   {
52912     try {
52913       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52914     } catch (std::out_of_range& e) {
52915       {
52916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52917       };
52918     } catch (std::exception& e) {
52919       {
52920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52921       };
52922     } catch (...) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52925       };
52926     }
52927   }
52928   jresult = (void *)result;
52929   return jresult;
52930 }
52931
52932
52933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52934   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52935
52936   arg1 = (Dali::Timer *)jarg1;
52937   {
52938     try {
52939       delete arg1;
52940     } catch (std::out_of_range& e) {
52941       {
52942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (std::exception& e) {
52945       {
52946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52947       };
52948     } catch (...) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52951       };
52952     }
52953   }
52954 }
52955
52956
52957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52958   void * jresult ;
52959   Dali::BaseHandle arg1 ;
52960   Dali::BaseHandle *argp1 ;
52961   Dali::Timer result;
52962
52963   argp1 = (Dali::BaseHandle *)jarg1;
52964   if (!argp1) {
52965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52966     return 0;
52967   }
52968   arg1 = *argp1;
52969   {
52970     try {
52971       result = Dali::Timer::DownCast(arg1);
52972     } catch (std::out_of_range& e) {
52973       {
52974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (std::exception& e) {
52977       {
52978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52979       };
52980     } catch (...) {
52981       {
52982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52983       };
52984     }
52985   }
52986   jresult = new Dali::Timer((const Dali::Timer &)result);
52987   return jresult;
52988 }
52989
52990
52991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52992   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52993
52994   arg1 = (Dali::Timer *)jarg1;
52995   {
52996     try {
52997       (arg1)->Start();
52998     } catch (std::out_of_range& e) {
52999       {
53000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (std::exception& e) {
53003       {
53004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53005       };
53006     } catch (...) {
53007       {
53008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53009       };
53010     }
53011   }
53012 }
53013
53014
53015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53016   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53017
53018   arg1 = (Dali::Timer *)jarg1;
53019   {
53020     try {
53021       (arg1)->Stop();
53022     } catch (std::out_of_range& e) {
53023       {
53024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53025       };
53026     } catch (std::exception& e) {
53027       {
53028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53029       };
53030     } catch (...) {
53031       {
53032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53033       };
53034     }
53035   }
53036 }
53037
53038
53039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53040   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53041   unsigned int arg2 ;
53042
53043   arg1 = (Dali::Timer *)jarg1;
53044   arg2 = (unsigned int)jarg2;
53045   {
53046     try {
53047       (arg1)->SetInterval(arg2);
53048     } catch (std::out_of_range& e) {
53049       {
53050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53051       };
53052     } catch (std::exception& e) {
53053       {
53054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53055       };
53056     } catch (...) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53059       };
53060     }
53061   }
53062 }
53063
53064
53065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53066   unsigned int jresult ;
53067   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53068   unsigned int result;
53069
53070   arg1 = (Dali::Timer *)jarg1;
53071   {
53072     try {
53073       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53085       };
53086     }
53087   }
53088   jresult = result;
53089   return jresult;
53090 }
53091
53092
53093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53094   unsigned int jresult ;
53095   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53096   bool result;
53097
53098   arg1 = (Dali::Timer *)jarg1;
53099   {
53100     try {
53101       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53102     } catch (std::out_of_range& e) {
53103       {
53104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (std::exception& e) {
53107       {
53108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53109       };
53110     } catch (...) {
53111       {
53112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53113       };
53114     }
53115   }
53116   jresult = result;
53117   return jresult;
53118 }
53119
53120
53121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53122   void * jresult ;
53123   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53124   Dali::Timer::TimerSignalType *result = 0 ;
53125
53126   arg1 = (Dali::Timer *)jarg1;
53127   {
53128     try {
53129       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53130     } catch (std::out_of_range& e) {
53131       {
53132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (std::exception& e) {
53135       {
53136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (...) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53141       };
53142     }
53143   }
53144   jresult = (void *)result;
53145   return jresult;
53146 }
53147
53148
53149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53150   void * jresult ;
53151   Dali::DragAndDropDetector *result = 0 ;
53152
53153   {
53154     try {
53155       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53156     } catch (std::out_of_range& e) {
53157       {
53158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (std::exception& e) {
53161       {
53162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53163       };
53164     } catch (...) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53167       };
53168     }
53169   }
53170   jresult = (void *)result;
53171   return jresult;
53172 }
53173
53174
53175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53176   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53177
53178   arg1 = (Dali::DragAndDropDetector *)jarg1;
53179   {
53180     try {
53181       delete arg1;
53182     } catch (std::out_of_range& e) {
53183       {
53184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53185       };
53186     } catch (std::exception& e) {
53187       {
53188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53189       };
53190     } catch (...) {
53191       {
53192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53193       };
53194     }
53195   }
53196 }
53197
53198
53199 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53200   char * jresult ;
53201   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53202   std::string *result = 0 ;
53203
53204   arg1 = (Dali::DragAndDropDetector *)jarg1;
53205   {
53206     try {
53207       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53208     } catch (std::out_of_range& e) {
53209       {
53210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (std::exception& e) {
53213       {
53214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (...) {
53217       {
53218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53219       };
53220     }
53221   }
53222   jresult = SWIG_csharp_string_callback(result->c_str());
53223   return jresult;
53224 }
53225
53226
53227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53228   void * jresult ;
53229   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53230   Dali::Vector2 result;
53231
53232   arg1 = (Dali::DragAndDropDetector *)jarg1;
53233   {
53234     try {
53235       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53236     } catch (std::out_of_range& e) {
53237       {
53238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53239       };
53240     } catch (std::exception& e) {
53241       {
53242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53243       };
53244     } catch (...) {
53245       {
53246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53247       };
53248     }
53249   }
53250   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53251   return jresult;
53252 }
53253
53254
53255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53256   void * jresult ;
53257   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53258   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53259
53260   arg1 = (Dali::DragAndDropDetector *)jarg1;
53261   {
53262     try {
53263       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53264     } catch (std::out_of_range& e) {
53265       {
53266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53267       };
53268     } catch (std::exception& e) {
53269       {
53270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53271       };
53272     } catch (...) {
53273       {
53274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53275       };
53276     }
53277   }
53278   jresult = (void *)result;
53279   return jresult;
53280 }
53281
53282
53283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53284   void * jresult ;
53285   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53286   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53287
53288   arg1 = (Dali::DragAndDropDetector *)jarg1;
53289   {
53290     try {
53291       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53292     } catch (std::out_of_range& e) {
53293       {
53294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53295       };
53296     } catch (std::exception& e) {
53297       {
53298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53299       };
53300     } catch (...) {
53301       {
53302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53303       };
53304     }
53305   }
53306   jresult = (void *)result;
53307   return jresult;
53308 }
53309
53310
53311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53312   void * jresult ;
53313   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53314   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53315
53316   arg1 = (Dali::DragAndDropDetector *)jarg1;
53317   {
53318     try {
53319       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53327       };
53328     } catch (...) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53331       };
53332     }
53333   }
53334   jresult = (void *)result;
53335   return jresult;
53336 }
53337
53338
53339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53340   void * jresult ;
53341   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53342   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53343
53344   arg1 = (Dali::DragAndDropDetector *)jarg1;
53345   {
53346     try {
53347       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53348     } catch (std::out_of_range& e) {
53349       {
53350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53351       };
53352     } catch (std::exception& e) {
53353       {
53354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53355       };
53356     } catch (...) {
53357       {
53358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53359       };
53360     }
53361   }
53362   jresult = (void *)result;
53363   return jresult;
53364 }
53365
53366
53367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53368   void * jresult ;
53369   Dali::ApplicationExtensions *result = 0 ;
53370
53371   {
53372     try {
53373       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53374     } catch (std::out_of_range& e) {
53375       {
53376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53377       };
53378     } catch (std::exception& e) {
53379       {
53380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53381       };
53382     } catch (...) {
53383       {
53384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53385       };
53386     }
53387   }
53388   jresult = (void *)result;
53389   return jresult;
53390 }
53391
53392
53393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53394   void * jresult ;
53395   Dali::Application *arg1 = (Dali::Application *) 0 ;
53396   Dali::ApplicationExtensions *result = 0 ;
53397
53398   arg1 = (Dali::Application *)jarg1;
53399   {
53400     try {
53401       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53402     } catch (std::out_of_range& e) {
53403       {
53404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53405       };
53406     } catch (std::exception& e) {
53407       {
53408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53409       };
53410     } catch (...) {
53411       {
53412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53413       };
53414     }
53415   }
53416   jresult = (void *)result;
53417   return jresult;
53418 }
53419
53420
53421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53422   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53423
53424   arg1 = (Dali::ApplicationExtensions *)jarg1;
53425   {
53426     try {
53427       delete arg1;
53428     } catch (std::out_of_range& e) {
53429       {
53430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53431       };
53432     } catch (std::exception& e) {
53433       {
53434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53435       };
53436     } catch (...) {
53437       {
53438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53439       };
53440     }
53441   }
53442 }
53443
53444
53445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53446   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53447
53448   arg1 = (Dali::ApplicationExtensions *)jarg1;
53449   {
53450     try {
53451       (arg1)->Init();
53452     } catch (std::out_of_range& e) {
53453       {
53454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53455       };
53456     } catch (std::exception& e) {
53457       {
53458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53459       };
53460     } catch (...) {
53461       {
53462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53463       };
53464     }
53465   }
53466 }
53467
53468
53469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53470   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53471
53472   arg1 = (Dali::ApplicationExtensions *)jarg1;
53473   {
53474     try {
53475       (arg1)->Terminate();
53476     } catch (std::out_of_range& e) {
53477       {
53478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53479       };
53480     } catch (std::exception& e) {
53481       {
53482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53483       };
53484     } catch (...) {
53485       {
53486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53487       };
53488     }
53489   }
53490 }
53491
53492
53493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53494   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53495
53496   arg1 = (Dali::ApplicationExtensions *)jarg1;
53497   {
53498     try {
53499       (arg1)->Pause();
53500     } catch (std::out_of_range& e) {
53501       {
53502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53503       };
53504     } catch (std::exception& e) {
53505       {
53506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53507       };
53508     } catch (...) {
53509       {
53510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53511       };
53512     }
53513   }
53514 }
53515
53516
53517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53518   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53519
53520   arg1 = (Dali::ApplicationExtensions *)jarg1;
53521   {
53522     try {
53523       (arg1)->Resume();
53524     } catch (std::out_of_range& e) {
53525       {
53526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53527       };
53528     } catch (std::exception& e) {
53529       {
53530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53531       };
53532     } catch (...) {
53533       {
53534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53535       };
53536     }
53537   }
53538 }
53539
53540
53541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53542   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53543
53544   arg1 = (Dali::ApplicationExtensions *)jarg1;
53545   {
53546     try {
53547       (arg1)->LanguageChange();
53548     } catch (std::out_of_range& e) {
53549       {
53550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53551       };
53552     } catch (std::exception& e) {
53553       {
53554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53555       };
53556     } catch (...) {
53557       {
53558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53559       };
53560     }
53561   }
53562 }
53563
53564
53565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53566   void * jresult ;
53567   Dali::PositionSize arg1 ;
53568   std::string *arg2 = 0 ;
53569   bool arg3 ;
53570   Dali::PositionSize *argp1 ;
53571   Dali::Window result;
53572
53573   argp1 = (Dali::PositionSize *)jarg1;
53574   if (!argp1) {
53575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53576     return 0;
53577   }
53578   arg1 = *argp1;
53579   if (!jarg2) {
53580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53581     return 0;
53582   }
53583   std::string arg2_str(jarg2);
53584   arg2 = &arg2_str;
53585   arg3 = jarg3 ? true : false;
53586   {
53587     try {
53588       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53589     } catch (std::out_of_range& e) {
53590       {
53591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53592       };
53593     } catch (std::exception& e) {
53594       {
53595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53596       };
53597     } catch (...) {
53598       {
53599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53600       };
53601     }
53602   }
53603   jresult = new Dali::Window((const Dali::Window &)result);
53604
53605   //argout typemap for const std::string&
53606
53607   return jresult;
53608 }
53609
53610
53611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53612   void * jresult ;
53613   Dali::PositionSize arg1 ;
53614   std::string *arg2 = 0 ;
53615   Dali::PositionSize *argp1 ;
53616   Dali::Window result;
53617
53618   argp1 = (Dali::PositionSize *)jarg1;
53619   if (!argp1) {
53620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53621     return 0;
53622   }
53623   arg1 = *argp1;
53624   if (!jarg2) {
53625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53626     return 0;
53627   }
53628   std::string arg2_str(jarg2);
53629   arg2 = &arg2_str;
53630   {
53631     try {
53632       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53633     } catch (std::out_of_range& e) {
53634       {
53635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53636       };
53637     } catch (std::exception& e) {
53638       {
53639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53640       };
53641     } catch (...) {
53642       {
53643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53644       };
53645     }
53646   }
53647   jresult = new Dali::Window((const Dali::Window &)result);
53648
53649   //argout typemap for const std::string&
53650
53651   return jresult;
53652 }
53653
53654
53655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53656   void * jresult ;
53657   Dali::PositionSize arg1 ;
53658   std::string *arg2 = 0 ;
53659   std::string *arg3 = 0 ;
53660   bool arg4 ;
53661   Dali::PositionSize *argp1 ;
53662   Dali::Window result;
53663
53664   argp1 = (Dali::PositionSize *)jarg1;
53665   if (!argp1) {
53666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53667     return 0;
53668   }
53669   arg1 = *argp1;
53670   if (!jarg2) {
53671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53672     return 0;
53673   }
53674   std::string arg2_str(jarg2);
53675   arg2 = &arg2_str;
53676   if (!jarg3) {
53677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53678     return 0;
53679   }
53680   std::string arg3_str(jarg3);
53681   arg3 = &arg3_str;
53682   arg4 = jarg4 ? true : false;
53683   {
53684     try {
53685       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53686     } catch (std::out_of_range& e) {
53687       {
53688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53689       };
53690     } catch (std::exception& e) {
53691       {
53692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53693       };
53694     } catch (...) {
53695       {
53696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53697       };
53698     }
53699   }
53700   jresult = new Dali::Window((const Dali::Window &)result);
53701
53702   //argout typemap for const std::string&
53703
53704
53705   //argout typemap for const std::string&
53706
53707   return jresult;
53708 }
53709
53710
53711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53712   void * jresult ;
53713   Dali::PositionSize arg1 ;
53714   std::string *arg2 = 0 ;
53715   std::string *arg3 = 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   if (!jarg3) {
53732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53733     return 0;
53734   }
53735   std::string arg3_str(jarg3);
53736   arg3 = &arg3_str;
53737   {
53738     try {
53739       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53747       };
53748     } catch (...) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53751       };
53752     }
53753   }
53754   jresult = new Dali::Window((const Dali::Window &)result);
53755
53756   //argout typemap for const std::string&
53757
53758
53759   //argout typemap for const std::string&
53760
53761   return jresult;
53762 }
53763
53764
53765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53766   void * jresult ;
53767   Dali::Window *result = 0 ;
53768
53769   {
53770     try {
53771       result = (Dali::Window *)new Dali::Window();
53772     } catch (std::out_of_range& e) {
53773       {
53774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53775       };
53776     } catch (std::exception& e) {
53777       {
53778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53779       };
53780     } catch (...) {
53781       {
53782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53783       };
53784     }
53785   }
53786   jresult = (void *)result;
53787   return jresult;
53788 }
53789
53790
53791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53792   Dali::Window *arg1 = (Dali::Window *) 0 ;
53793
53794   arg1 = (Dali::Window *)jarg1;
53795   {
53796     try {
53797       delete arg1;
53798     } catch (std::out_of_range& e) {
53799       {
53800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53801       };
53802     } catch (std::exception& e) {
53803       {
53804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53805       };
53806     } catch (...) {
53807       {
53808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53809       };
53810     }
53811   }
53812 }
53813
53814
53815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53816   void * jresult ;
53817   Dali::Window *arg1 = 0 ;
53818   Dali::Window *result = 0 ;
53819
53820   arg1 = (Dali::Window *)jarg1;
53821   if (!arg1) {
53822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53823     return 0;
53824   }
53825   {
53826     try {
53827       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53828     } catch (std::out_of_range& e) {
53829       {
53830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53831       };
53832     } catch (std::exception& e) {
53833       {
53834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53835       };
53836     } catch (...) {
53837       {
53838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53839       };
53840     }
53841   }
53842   jresult = (void *)result;
53843   return jresult;
53844 }
53845
53846
53847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53848   void * jresult ;
53849   Dali::Window *arg1 = (Dali::Window *) 0 ;
53850   Dali::Window *arg2 = 0 ;
53851   Dali::Window *result = 0 ;
53852
53853   arg1 = (Dali::Window *)jarg1;
53854   arg2 = (Dali::Window *)jarg2;
53855   if (!arg2) {
53856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53857     return 0;
53858   }
53859   {
53860     try {
53861       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53862     } catch (std::out_of_range& e) {
53863       {
53864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53865       };
53866     } catch (std::exception& e) {
53867       {
53868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53869       };
53870     } catch (...) {
53871       {
53872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53873       };
53874     }
53875   }
53876   jresult = (void *)result;
53877   return jresult;
53878 }
53879
53880
53881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53882   Dali::Window *arg1 = (Dali::Window *) 0 ;
53883   Dali::Window::IndicatorVisibleMode arg2 ;
53884
53885   arg1 = (Dali::Window *)jarg1;
53886   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53887   {
53888     try {
53889       (arg1)->ShowIndicator(arg2);
53890     } catch (std::out_of_range& e) {
53891       {
53892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53893       };
53894     } catch (std::exception& e) {
53895       {
53896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53897       };
53898     } catch (...) {
53899       {
53900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53901       };
53902     }
53903   }
53904 }
53905
53906
53907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53908   Dali::Window *arg1 = (Dali::Window *) 0 ;
53909   Dali::Window::IndicatorBgOpacity arg2 ;
53910
53911   arg1 = (Dali::Window *)jarg1;
53912   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53913   {
53914     try {
53915       (arg1)->SetIndicatorBgOpacity(arg2);
53916     } catch (std::out_of_range& e) {
53917       {
53918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53919       };
53920     } catch (std::exception& e) {
53921       {
53922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53923       };
53924     } catch (...) {
53925       {
53926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53927       };
53928     }
53929   }
53930 }
53931
53932
53933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53934   Dali::Window *arg1 = (Dali::Window *) 0 ;
53935   Dali::Window::WindowOrientation arg2 ;
53936
53937   arg1 = (Dali::Window *)jarg1;
53938   arg2 = (Dali::Window::WindowOrientation)jarg2;
53939   {
53940     try {
53941       (arg1)->RotateIndicator(arg2);
53942     } catch (std::out_of_range& e) {
53943       {
53944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53945       };
53946     } catch (std::exception& e) {
53947       {
53948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53949       };
53950     } catch (...) {
53951       {
53952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53953       };
53954     }
53955   }
53956 }
53957
53958
53959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53960   Dali::Window *arg1 = (Dali::Window *) 0 ;
53961   std::string arg2 ;
53962   std::string arg3 ;
53963
53964   arg1 = (Dali::Window *)jarg1;
53965   if (!jarg2) {
53966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53967     return ;
53968   }
53969   (&arg2)->assign(jarg2);
53970   if (!jarg3) {
53971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53972     return ;
53973   }
53974   (&arg3)->assign(jarg3);
53975   {
53976     try {
53977       (arg1)->SetClass(arg2,arg3);
53978     } catch (std::out_of_range& e) {
53979       {
53980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53981       };
53982     } catch (std::exception& e) {
53983       {
53984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (...) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53989       };
53990     }
53991   }
53992 }
53993
53994
53995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53996   Dali::Window *arg1 = (Dali::Window *) 0 ;
53997
53998   arg1 = (Dali::Window *)jarg1;
53999   {
54000     try {
54001       (arg1)->Raise();
54002     } catch (std::out_of_range& e) {
54003       {
54004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54005       };
54006     } catch (std::exception& e) {
54007       {
54008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54009       };
54010     } catch (...) {
54011       {
54012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54013       };
54014     }
54015   }
54016 }
54017
54018
54019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
54020   Dali::Window *arg1 = (Dali::Window *) 0 ;
54021
54022   arg1 = (Dali::Window *)jarg1;
54023   {
54024     try {
54025       (arg1)->Lower();
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54033       };
54034     } catch (...) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54037       };
54038     }
54039   }
54040 }
54041
54042
54043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
54044   Dali::Window *arg1 = (Dali::Window *) 0 ;
54045
54046   arg1 = (Dali::Window *)jarg1;
54047   {
54048     try {
54049       (arg1)->Activate();
54050     } catch (std::out_of_range& e) {
54051       {
54052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54053       };
54054     } catch (std::exception& e) {
54055       {
54056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54057       };
54058     } catch (...) {
54059       {
54060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54061       };
54062     }
54063   }
54064 }
54065
54066
54067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
54068   Dali::Window *arg1 = (Dali::Window *) 0 ;
54069   Dali::Window::WindowOrientation arg2 ;
54070
54071   arg1 = (Dali::Window *)jarg1;
54072   arg2 = (Dali::Window::WindowOrientation)jarg2;
54073   {
54074     try {
54075       (arg1)->AddAvailableOrientation(arg2);
54076     } catch (std::out_of_range& e) {
54077       {
54078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54079       };
54080     } catch (std::exception& e) {
54081       {
54082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54083       };
54084     } catch (...) {
54085       {
54086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54087       };
54088     }
54089   }
54090 }
54091
54092
54093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
54094   Dali::Window *arg1 = (Dali::Window *) 0 ;
54095   Dali::Window::WindowOrientation arg2 ;
54096
54097   arg1 = (Dali::Window *)jarg1;
54098   arg2 = (Dali::Window::WindowOrientation)jarg2;
54099   {
54100     try {
54101       (arg1)->RemoveAvailableOrientation(arg2);
54102     } catch (std::out_of_range& e) {
54103       {
54104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54105       };
54106     } catch (std::exception& e) {
54107       {
54108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54109       };
54110     } catch (...) {
54111       {
54112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54113       };
54114     }
54115   }
54116 }
54117
54118
54119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
54120   Dali::Window *arg1 = (Dali::Window *) 0 ;
54121   Dali::Window::WindowOrientation arg2 ;
54122
54123   arg1 = (Dali::Window *)jarg1;
54124   arg2 = (Dali::Window::WindowOrientation)jarg2;
54125   {
54126     try {
54127       (arg1)->SetPreferredOrientation(arg2);
54128     } catch (std::out_of_range& e) {
54129       {
54130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54131       };
54132     } catch (std::exception& e) {
54133       {
54134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54135       };
54136     } catch (...) {
54137       {
54138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54139       };
54140     }
54141   }
54142 }
54143
54144
54145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
54146   int jresult ;
54147   Dali::Window *arg1 = (Dali::Window *) 0 ;
54148   Dali::Window::WindowOrientation result;
54149
54150   arg1 = (Dali::Window *)jarg1;
54151   {
54152     try {
54153       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
54154     } catch (std::out_of_range& e) {
54155       {
54156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54157       };
54158     } catch (std::exception& e) {
54159       {
54160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54161       };
54162     } catch (...) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54165       };
54166     }
54167   }
54168   jresult = (int)result;
54169   return jresult;
54170 }
54171
54172
54173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
54174   void * jresult ;
54175   Dali::Window *arg1 = (Dali::Window *) 0 ;
54176   Dali::DragAndDropDetector result;
54177
54178   arg1 = (Dali::Window *)jarg1;
54179   {
54180     try {
54181       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
54182     } catch (std::out_of_range& e) {
54183       {
54184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54185       };
54186     } catch (std::exception& e) {
54187       {
54188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54189       };
54190     } catch (...) {
54191       {
54192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54193       };
54194     }
54195   }
54196   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
54197   return jresult;
54198 }
54199
54200
54201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
54202   void * jresult ;
54203   Dali::Window *arg1 = (Dali::Window *) 0 ;
54204   Dali::Any result;
54205
54206   arg1 = (Dali::Window *)jarg1;
54207   {
54208     try {
54209       result = ((Dali::Window const *)arg1)->GetNativeHandle();
54210     } catch (std::out_of_range& e) {
54211       {
54212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54213       };
54214     } catch (std::exception& e) {
54215       {
54216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54217       };
54218     } catch (...) {
54219       {
54220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54221       };
54222     }
54223   }
54224   jresult = new Dali::Any((const Dali::Any &)result);
54225   return jresult;
54226 }
54227
54228
54229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54230   void * jresult ;
54231   Dali::Window arg1 ;
54232   Dali::Window *argp1 ;
54233   Dali::DevelWindow::FocusSignalType *result = 0 ;
54234
54235   argp1 = (Dali::Window *)jarg1;
54236   if (!argp1) {
54237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54238     return 0;
54239   }
54240   arg1 = *argp1;
54241   {
54242     try {
54243       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54244     } catch (std::out_of_range& e) {
54245       {
54246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54247       };
54248     } catch (std::exception& e) {
54249       {
54250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54251       };
54252     } catch (...) {
54253       {
54254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54255       };
54256     }
54257   }
54258   jresult = (void *)result;
54259   return jresult;
54260 }
54261
54262
54263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54264   Dali::Window arg1 ;
54265   bool arg2 ;
54266   Dali::Window *argp1 ;
54267
54268   argp1 = (Dali::Window *)jarg1;
54269   if (!argp1) {
54270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54271     return ;
54272   }
54273   arg1 = *argp1;
54274   arg2 = jarg2 ? true : false;
54275   {
54276     try {
54277       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (...) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54289       };
54290     }
54291   }
54292 }
54293
54294
54295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54296   unsigned int jresult ;
54297   Dali::Window arg1 ;
54298   Dali::Window *argp1 ;
54299   bool result;
54300
54301   argp1 = (Dali::Window *)jarg1;
54302   if (!argp1) {
54303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54304     return 0;
54305   }
54306   arg1 = *argp1;
54307   {
54308     try {
54309       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54310     } catch (std::out_of_range& e) {
54311       {
54312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54313       };
54314     } catch (std::exception& e) {
54315       {
54316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54317       };
54318     } catch (...) {
54319       {
54320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54321       };
54322     }
54323   }
54324   jresult = result;
54325   return jresult;
54326 }
54327
54328
54329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54330   Dali::Window arg1 ;
54331   Dali::Window *argp1 ;
54332
54333   argp1 = (Dali::Window *)jarg1;
54334   if (!argp1) {
54335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54336     return ;
54337   }
54338   arg1 = *argp1;
54339   {
54340     try {
54341       Dali::DevelWindow::Show(arg1);
54342     } catch (std::out_of_range& e) {
54343       {
54344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54345       };
54346     } catch (std::exception& e) {
54347       {
54348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54349       };
54350     } catch (...) {
54351       {
54352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54353       };
54354     }
54355   }
54356 }
54357
54358
54359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54360   Dali::Window arg1 ;
54361   Dali::Window *argp1 ;
54362
54363   argp1 = (Dali::Window *)jarg1;
54364   if (!argp1) {
54365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54366     return ;
54367   }
54368   arg1 = *argp1;
54369   {
54370     try {
54371       Dali::DevelWindow::Hide(arg1);
54372     } catch (std::out_of_range& e) {
54373       {
54374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54375       };
54376     } catch (std::exception& e) {
54377       {
54378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54379       };
54380     } catch (...) {
54381       {
54382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54383       };
54384     }
54385   }
54386 }
54387
54388
54389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54390   unsigned int jresult ;
54391   Dali::Window arg1 ;
54392   Dali::Window *argp1 ;
54393   bool result;
54394
54395   argp1 = (Dali::Window *)jarg1;
54396   if (!argp1) {
54397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54398     return 0;
54399   }
54400   arg1 = *argp1;
54401   {
54402     try {
54403       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54404     } catch (std::out_of_range& e) {
54405       {
54406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54407       };
54408     } catch (std::exception& e) {
54409       {
54410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54411       };
54412     } catch (...) {
54413       {
54414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54415       };
54416     }
54417   }
54418   jresult = result;
54419   return jresult;
54420 }
54421
54422
54423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHintCount(void * jarg1) {
54424   unsigned int jresult ;
54425   Dali::Window arg1 ;
54426   Dali::Window *argp1 ;
54427   unsigned int result;
54428
54429   argp1 = (Dali::Window *)jarg1;
54430   if (!argp1) {
54431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54432     return 0;
54433   }
54434   arg1 = *argp1;
54435   {
54436     try {
54437       result = (unsigned int)Dali::DevelWindow::GetSupportedAuxiliaryHintCount(arg1);
54438     } catch (std::out_of_range& e) {
54439       {
54440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54441       };
54442     } catch (std::exception& e) {
54443       {
54444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54445       };
54446     } catch (...) {
54447       {
54448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54449       };
54450     }
54451   }
54452   jresult = result;
54453   return jresult;
54454 }
54455
54456
54457 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetSupportedAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54458   char * jresult ;
54459   Dali::Window arg1 ;
54460   unsigned int arg2 ;
54461   Dali::Window *argp1 ;
54462   std::string result;
54463
54464   argp1 = (Dali::Window *)jarg1;
54465   if (!argp1) {
54466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54467     return 0;
54468   }
54469   arg1 = *argp1;
54470   arg2 = (unsigned int)jarg2;
54471   {
54472     try {
54473       result = Dali::DevelWindow::GetSupportedAuxiliaryHint(arg1,arg2);
54474     } catch (std::out_of_range& e) {
54475       {
54476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (std::exception& e) {
54479       {
54480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (...) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54485       };
54486     }
54487   }
54488   jresult = SWIG_csharp_string_callback((&result)->c_str());
54489   return jresult;
54490 }
54491
54492
54493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AddAuxiliaryHint(void * jarg1, char * jarg2, char * jarg3) {
54494   unsigned int jresult ;
54495   Dali::Window arg1 ;
54496   std::string *arg2 = 0 ;
54497   std::string *arg3 = 0 ;
54498   Dali::Window *argp1 ;
54499   unsigned int result;
54500
54501   argp1 = (Dali::Window *)jarg1;
54502   if (!argp1) {
54503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54504     return 0;
54505   }
54506   arg1 = *argp1;
54507   if (!jarg2) {
54508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54509     return 0;
54510   }
54511   std::string arg2_str(jarg2);
54512   arg2 = &arg2_str;
54513   if (!jarg3) {
54514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54515     return 0;
54516   }
54517   std::string arg3_str(jarg3);
54518   arg3 = &arg3_str;
54519   {
54520     try {
54521       result = (unsigned int)Dali::DevelWindow::AddAuxiliaryHint(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54522     } catch (std::out_of_range& e) {
54523       {
54524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54525       };
54526     } catch (std::exception& e) {
54527       {
54528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54529       };
54530     } catch (...) {
54531       {
54532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54533       };
54534     }
54535   }
54536   jresult = result;
54537
54538   //argout typemap for const std::string&
54539
54540
54541   //argout typemap for const std::string&
54542
54543   return jresult;
54544 }
54545
54546
54547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RemoveAuxiliaryHint(void * jarg1, unsigned int jarg2) {
54548   unsigned int jresult ;
54549   Dali::Window arg1 ;
54550   unsigned int arg2 ;
54551   Dali::Window *argp1 ;
54552   bool result;
54553
54554   argp1 = (Dali::Window *)jarg1;
54555   if (!argp1) {
54556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54557     return 0;
54558   }
54559   arg1 = *argp1;
54560   arg2 = (unsigned int)jarg2;
54561   {
54562     try {
54563       result = (bool)Dali::DevelWindow::RemoveAuxiliaryHint(arg1,arg2);
54564     } catch (std::out_of_range& e) {
54565       {
54566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54567       };
54568     } catch (std::exception& e) {
54569       {
54570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (...) {
54573       {
54574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54575       };
54576     }
54577   }
54578   jresult = result;
54579   return jresult;
54580 }
54581
54582
54583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetAuxiliaryHintValue(void * jarg1, unsigned int jarg2, char * jarg3) {
54584   unsigned int jresult ;
54585   Dali::Window arg1 ;
54586   unsigned int arg2 ;
54587   std::string *arg3 = 0 ;
54588   Dali::Window *argp1 ;
54589   bool result;
54590
54591   argp1 = (Dali::Window *)jarg1;
54592   if (!argp1) {
54593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54594     return 0;
54595   }
54596   arg1 = *argp1;
54597   arg2 = (unsigned int)jarg2;
54598   if (!jarg3) {
54599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54600     return 0;
54601   }
54602   std::string arg3_str(jarg3);
54603   arg3 = &arg3_str;
54604   {
54605     try {
54606       result = (bool)Dali::DevelWindow::SetAuxiliaryHintValue(arg1,arg2,(std::string const &)*arg3);
54607     } catch (std::out_of_range& e) {
54608       {
54609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54610       };
54611     } catch (std::exception& e) {
54612       {
54613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54614       };
54615     } catch (...) {
54616       {
54617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54618       };
54619     }
54620   }
54621   jresult = result;
54622
54623   //argout typemap for const std::string&
54624
54625   return jresult;
54626 }
54627
54628
54629 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintValue(void * jarg1, unsigned int jarg2) {
54630   char * jresult ;
54631   Dali::Window arg1 ;
54632   unsigned int arg2 ;
54633   Dali::Window *argp1 ;
54634   std::string result;
54635
54636   argp1 = (Dali::Window *)jarg1;
54637   if (!argp1) {
54638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54639     return 0;
54640   }
54641   arg1 = *argp1;
54642   arg2 = (unsigned int)jarg2;
54643   {
54644     try {
54645       result = Dali::DevelWindow::GetAuxiliaryHintValue(arg1,arg2);
54646     } catch (std::out_of_range& e) {
54647       {
54648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54649       };
54650     } catch (std::exception& e) {
54651       {
54652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54653       };
54654     } catch (...) {
54655       {
54656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54657       };
54658     }
54659   }
54660   jresult = SWIG_csharp_string_callback((&result)->c_str());
54661   return jresult;
54662 }
54663
54664
54665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetAuxiliaryHintId(void * jarg1, char * jarg2) {
54666   unsigned int jresult ;
54667   Dali::Window arg1 ;
54668   std::string *arg2 = 0 ;
54669   Dali::Window *argp1 ;
54670   unsigned int result;
54671
54672   argp1 = (Dali::Window *)jarg1;
54673   if (!argp1) {
54674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54675     return 0;
54676   }
54677   arg1 = *argp1;
54678   if (!jarg2) {
54679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54680     return 0;
54681   }
54682   std::string arg2_str(jarg2);
54683   arg2 = &arg2_str;
54684   {
54685     try {
54686       result = (unsigned int)Dali::DevelWindow::GetAuxiliaryHintId(arg1,(std::string const &)*arg2);
54687     } catch (std::out_of_range& e) {
54688       {
54689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54690       };
54691     } catch (std::exception& e) {
54692       {
54693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (...) {
54696       {
54697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54698       };
54699     }
54700   }
54701   jresult = result;
54702
54703   //argout typemap for const std::string&
54704
54705   return jresult;
54706 }
54707
54708
54709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetInputRegion(void * jarg1, void * jarg2) {
54710   Dali::Window arg1 ;
54711   Dali::Rect< int > *arg2 = 0 ;
54712   Dali::Window *argp1 ;
54713
54714   argp1 = (Dali::Window *)jarg1;
54715   if (!argp1) {
54716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54717     return ;
54718   }
54719   arg1 = *argp1;
54720   arg2 = (Dali::Rect< int > *)jarg2;
54721   if (!arg2) {
54722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
54723     return ;
54724   }
54725   {
54726     try {
54727       Dali::DevelWindow::SetInputRegion(arg1,(Dali::Rect< int > const &)*arg2);
54728     } catch (std::out_of_range& e) {
54729       {
54730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54731       };
54732     } catch (std::exception& e) {
54733       {
54734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54735       };
54736     } catch (...) {
54737       {
54738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54739       };
54740     }
54741   }
54742 }
54743
54744
54745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetType(void * jarg1, int jarg2) {
54746   Dali::Window arg1 ;
54747   Dali::DevelWindow::Type arg2 ;
54748   Dali::Window *argp1 ;
54749
54750   argp1 = (Dali::Window *)jarg1;
54751   if (!argp1) {
54752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54753     return ;
54754   }
54755   arg1 = *argp1;
54756   arg2 = (Dali::DevelWindow::Type)jarg2;
54757   {
54758     try {
54759       Dali::DevelWindow::SetType(arg1,arg2);
54760     } catch (std::out_of_range& e) {
54761       {
54762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54763       };
54764     } catch (std::exception& e) {
54765       {
54766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54767       };
54768     } catch (...) {
54769       {
54770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54771       };
54772     }
54773   }
54774 }
54775
54776
54777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetType(void * jarg1) {
54778   int jresult ;
54779   Dali::Window arg1 ;
54780   Dali::Window *argp1 ;
54781   Dali::DevelWindow::Type result;
54782
54783   argp1 = (Dali::Window *)jarg1;
54784   if (!argp1) {
54785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54786     return 0;
54787   }
54788   arg1 = *argp1;
54789   {
54790     try {
54791       result = (Dali::DevelWindow::Type)Dali::DevelWindow::GetType(arg1);
54792     } catch (std::out_of_range& e) {
54793       {
54794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (std::exception& e) {
54797       {
54798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54803       };
54804     }
54805   }
54806   jresult = (int)result;
54807   return jresult;
54808 }
54809
54810
54811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetNotificationLevel(void * jarg1, int jarg2) {
54812   unsigned int jresult ;
54813   Dali::Window arg1 ;
54814   Dali::DevelWindow::NotificationLevel::Type arg2 ;
54815   Dali::Window *argp1 ;
54816   bool result;
54817
54818   argp1 = (Dali::Window *)jarg1;
54819   if (!argp1) {
54820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54821     return 0;
54822   }
54823   arg1 = *argp1;
54824   arg2 = (Dali::DevelWindow::NotificationLevel::Type)jarg2;
54825   {
54826     try {
54827       result = (bool)Dali::DevelWindow::SetNotificationLevel(arg1,arg2);
54828     } catch (std::out_of_range& e) {
54829       {
54830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54831       };
54832     } catch (std::exception& e) {
54833       {
54834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54835       };
54836     } catch (...) {
54837       {
54838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54839       };
54840     }
54841   }
54842   jresult = result;
54843   return jresult;
54844 }
54845
54846
54847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetNotificationLevel(void * jarg1) {
54848   int jresult ;
54849   Dali::Window arg1 ;
54850   Dali::Window *argp1 ;
54851   Dali::DevelWindow::NotificationLevel::Type result;
54852
54853   argp1 = (Dali::Window *)jarg1;
54854   if (!argp1) {
54855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54856     return 0;
54857   }
54858   arg1 = *argp1;
54859   {
54860     try {
54861       result = (Dali::DevelWindow::NotificationLevel::Type)Dali::DevelWindow::GetNotificationLevel(arg1);
54862     } catch (std::out_of_range& e) {
54863       {
54864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (std::exception& e) {
54867       {
54868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54869       };
54870     } catch (...) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54873       };
54874     }
54875   }
54876   jresult = (int)result;
54877   return jresult;
54878 }
54879
54880
54881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetOpaqueState(void * jarg1, unsigned int jarg2) {
54882   Dali::Window arg1 ;
54883   bool arg2 ;
54884   Dali::Window *argp1 ;
54885
54886   argp1 = (Dali::Window *)jarg1;
54887   if (!argp1) {
54888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54889     return ;
54890   }
54891   arg1 = *argp1;
54892   arg2 = jarg2 ? true : false;
54893   {
54894     try {
54895       Dali::DevelWindow::SetOpaqueState(arg1,arg2);
54896     } catch (std::out_of_range& e) {
54897       {
54898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (std::exception& e) {
54901       {
54902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54907       };
54908     }
54909   }
54910 }
54911
54912
54913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsOpaqueState(void * jarg1) {
54914   unsigned int jresult ;
54915   Dali::Window arg1 ;
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   {
54926     try {
54927       result = (bool)Dali::DevelWindow::IsOpaqueState(arg1);
54928     } catch (std::out_of_range& e) {
54929       {
54930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54931       };
54932     } catch (std::exception& e) {
54933       {
54934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54935       };
54936     } catch (...) {
54937       {
54938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54939       };
54940     }
54941   }
54942   jresult = result;
54943   return jresult;
54944 }
54945
54946
54947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetScreenMode(void * jarg1, int jarg2) {
54948   unsigned int jresult ;
54949   Dali::Window arg1 ;
54950   Dali::DevelWindow::ScreenMode::Type arg2 ;
54951   Dali::Window *argp1 ;
54952   bool 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   arg2 = (Dali::DevelWindow::ScreenMode::Type)jarg2;
54961   {
54962     try {
54963       result = (bool)Dali::DevelWindow::SetScreenMode(arg1,arg2);
54964     } catch (std::out_of_range& e) {
54965       {
54966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54967       };
54968     } catch (std::exception& e) {
54969       {
54970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54971       };
54972     } catch (...) {
54973       {
54974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54975       };
54976     }
54977   }
54978   jresult = result;
54979   return jresult;
54980 }
54981
54982
54983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetScreenMode(void * jarg1) {
54984   int jresult ;
54985   Dali::Window arg1 ;
54986   Dali::Window *argp1 ;
54987   Dali::DevelWindow::ScreenMode::Type result;
54988
54989   argp1 = (Dali::Window *)jarg1;
54990   if (!argp1) {
54991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54992     return 0;
54993   }
54994   arg1 = *argp1;
54995   {
54996     try {
54997       result = (Dali::DevelWindow::ScreenMode::Type)Dali::DevelWindow::GetScreenMode(arg1);
54998     } catch (std::out_of_range& e) {
54999       {
55000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55001       };
55002     } catch (std::exception& e) {
55003       {
55004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55005       };
55006     } catch (...) {
55007       {
55008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55009       };
55010     }
55011   }
55012   jresult = (int)result;
55013   return jresult;
55014 }
55015
55016
55017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SetBrightness(void * jarg1, int jarg2) {
55018   unsigned int jresult ;
55019   Dali::Window arg1 ;
55020   int arg2 ;
55021   Dali::Window *argp1 ;
55022   bool result;
55023
55024   argp1 = (Dali::Window *)jarg1;
55025   if (!argp1) {
55026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55027     return 0;
55028   }
55029   arg1 = *argp1;
55030   arg2 = (int)jarg2;
55031   {
55032     try {
55033       result = (bool)Dali::DevelWindow::SetBrightness(arg1,arg2);
55034     } catch (std::out_of_range& e) {
55035       {
55036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55037       };
55038     } catch (std::exception& e) {
55039       {
55040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55041       };
55042     } catch (...) {
55043       {
55044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55045       };
55046     }
55047   }
55048   jresult = result;
55049   return jresult;
55050 }
55051
55052
55053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetBrightness(void * jarg1) {
55054   int jresult ;
55055   Dali::Window arg1 ;
55056   Dali::Window *argp1 ;
55057   int result;
55058
55059   argp1 = (Dali::Window *)jarg1;
55060   if (!argp1) {
55061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
55062     return 0;
55063   }
55064   arg1 = *argp1;
55065   {
55066     try {
55067       result = (int)Dali::DevelWindow::GetBrightness(arg1);
55068     } catch (std::out_of_range& e) {
55069       {
55070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (std::exception& e) {
55073       {
55074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (...) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55079       };
55080     }
55081   }
55082   jresult = result;
55083   return jresult;
55084 }
55085
55086
55087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55088   void * jresult ;
55089   Dali::Application result;
55090
55091   {
55092     try {
55093       result = Dali::Application::New();
55094     } catch (std::out_of_range& e) {
55095       {
55096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55097       };
55098     } catch (std::exception& e) {
55099       {
55100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55101       };
55102     } catch (...) {
55103       {
55104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55105       };
55106     }
55107   }
55108   jresult = new Dali::Application((const Dali::Application &)result);
55109   return jresult;
55110 }
55111
55112
55113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55114   void * jresult ;
55115   int *arg1 = (int *) 0 ;
55116   char ***arg2 ;
55117   Dali::Application result;
55118
55119   {
55120     // Todo generate argv data from the C# args
55121     char **array;         // two dimensional array
55122     int numStrings = 1;     // number of strings
55123     int stringLength = 30;      // max string length.
55124     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55125     argV = array;
55126
55127     // allocate the string data
55128     for( int i=0; i < numStrings; i++)
55129     {
55130       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55131     }
55132     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55133
55134     strcpy( array[0], "dali-csharp-app");
55135
55136     arg1 = &argC;
55137     arg2 = &argV;
55138   }
55139   {
55140     try {
55141       result = Dali::Application::New(arg1,arg2);
55142     } catch (std::out_of_range& e) {
55143       {
55144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55145       };
55146     } catch (std::exception& e) {
55147       {
55148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55149       };
55150     } catch (...) {
55151       {
55152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55153       };
55154     }
55155   }
55156   jresult = new Dali::Application((const Dali::Application &)result);
55157   return jresult;
55158 }
55159
55160
55161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55162   void * jresult ;
55163   int *arg1 = (int *) 0 ;
55164   char ***arg2 ;
55165   std::string *arg3 = 0 ;
55166   Dali::Application result;
55167
55168   {
55169     // Todo generate argv data from the C# args
55170     char **array;         // two dimensional array
55171     int numStrings = 1;     // number of strings
55172     int stringLength = 30;      // max string length.
55173     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55174     argV = array;
55175
55176     // allocate the string data
55177     for( int i=0; i < numStrings; i++)
55178     {
55179       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55180     }
55181     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55182
55183     strcpy( array[0], "dali-csharp-app");
55184
55185     arg1 = &argC;
55186     arg2 = &argV;
55187   }
55188   if (!jarg3) {
55189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55190     return 0;
55191   }
55192   std::string arg3_str(jarg3);
55193   arg3 = &arg3_str;
55194   {
55195     try {
55196       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55197     } catch (std::out_of_range& e) {
55198       {
55199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55200       };
55201     } catch (std::exception& e) {
55202       {
55203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55204       };
55205     } catch (...) {
55206       {
55207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55208       };
55209     }
55210   }
55211   jresult = new Dali::Application((const Dali::Application &)result);
55212
55213   //argout typemap for const std::string&
55214
55215   return jresult;
55216 }
55217
55218
55219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55220   void * jresult ;
55221   int *arg1 = (int *) 0 ;
55222   char ***arg2 ;
55223   std::string *arg3 = 0 ;
55224   Dali::Application::WINDOW_MODE arg4 ;
55225   Dali::Application result;
55226
55227   {
55228     // Todo generate argv data from the C# args
55229     char **array;         // two dimensional array
55230     int numStrings = 1;     // number of strings
55231     int stringLength = 30;      // max string length.
55232     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55233     argV = array;
55234
55235     // allocate the string data
55236     for( int i=0; i < numStrings; i++)
55237     {
55238       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55239     }
55240     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55241
55242     strcpy( array[0], "dali-csharp-app");
55243
55244     arg1 = &argC;
55245     arg2 = &argV;
55246   }
55247   if (!jarg3) {
55248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55249     return 0;
55250   }
55251   std::string arg3_str(jarg3);
55252   arg3 = &arg3_str;
55253   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55254   {
55255     try {
55256       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55257     } catch (std::out_of_range& e) {
55258       {
55259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55260       };
55261     } catch (std::exception& e) {
55262       {
55263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55264       };
55265     } catch (...) {
55266       {
55267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55268       };
55269     }
55270   }
55271   jresult = new Dali::Application((const Dali::Application &)result);
55272
55273   //argout typemap for const std::string&
55274
55275   return jresult;
55276 }
55277
55278
55279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55280   void * jresult ;
55281   Dali::Application *result = 0 ;
55282
55283   {
55284     try {
55285       result = (Dali::Application *)new Dali::Application();
55286     } catch (std::out_of_range& e) {
55287       {
55288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55289       };
55290     } catch (std::exception& e) {
55291       {
55292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55293       };
55294     } catch (...) {
55295       {
55296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55297       };
55298     }
55299   }
55300   jresult = (void *)result;
55301   return jresult;
55302 }
55303
55304
55305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55306   void * jresult ;
55307   Dali::Application *arg1 = 0 ;
55308   Dali::Application *result = 0 ;
55309
55310   arg1 = (Dali::Application *)jarg1;
55311   if (!arg1) {
55312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55313     return 0;
55314   }
55315   {
55316     try {
55317       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55318     } catch (std::out_of_range& e) {
55319       {
55320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55321       };
55322     } catch (std::exception& e) {
55323       {
55324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55325       };
55326     } catch (...) {
55327       {
55328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55329       };
55330     }
55331   }
55332   jresult = (void *)result;
55333   return jresult;
55334 }
55335
55336
55337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55338   void * jresult ;
55339   Dali::Application *arg1 = (Dali::Application *) 0 ;
55340   Dali::Application *arg2 = 0 ;
55341   Dali::Application *result = 0 ;
55342
55343   arg1 = (Dali::Application *)jarg1;
55344   arg2 = (Dali::Application *)jarg2;
55345   if (!arg2) {
55346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55347     return 0;
55348   }
55349   {
55350     try {
55351       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55352     } catch (std::out_of_range& e) {
55353       {
55354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55355       };
55356     } catch (std::exception& e) {
55357       {
55358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (...) {
55361       {
55362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55363       };
55364     }
55365   }
55366   jresult = (void *)result;
55367   return jresult;
55368 }
55369
55370
55371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55372   Dali::Application *arg1 = (Dali::Application *) 0 ;
55373
55374   arg1 = (Dali::Application *)jarg1;
55375   {
55376     try {
55377       delete arg1;
55378     } catch (std::out_of_range& e) {
55379       {
55380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55381       };
55382     } catch (std::exception& e) {
55383       {
55384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55389       };
55390     }
55391   }
55392 }
55393
55394
55395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55396   Dali::Application *arg1 = (Dali::Application *) 0 ;
55397
55398   arg1 = (Dali::Application *)jarg1;
55399   {
55400     try {
55401       (arg1)->MainLoop();
55402     } catch (std::out_of_range& e) {
55403       {
55404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55405       };
55406     } catch (std::exception& e) {
55407       {
55408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55409       };
55410     } catch (...) {
55411       {
55412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55413       };
55414     }
55415   }
55416 }
55417
55418
55419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55420   Dali::Application *arg1 = (Dali::Application *) 0 ;
55421   Configuration::ContextLoss arg2 ;
55422   Configuration::ContextLoss *argp2 ;
55423
55424   arg1 = (Dali::Application *)jarg1;
55425   argp2 = (Configuration::ContextLoss *)jarg2;
55426   if (!argp2) {
55427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55428     return ;
55429   }
55430   arg2 = *argp2;
55431   {
55432     try {
55433       (arg1)->MainLoop(arg2);
55434     } catch (std::out_of_range& e) {
55435       {
55436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55437       };
55438     } catch (std::exception& e) {
55439       {
55440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55441       };
55442     } catch (...) {
55443       {
55444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55445       };
55446     }
55447   }
55448 }
55449
55450
55451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55452   Dali::Application *arg1 = (Dali::Application *) 0 ;
55453
55454   arg1 = (Dali::Application *)jarg1;
55455   {
55456     try {
55457       (arg1)->Lower();
55458     } catch (std::out_of_range& e) {
55459       {
55460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55461       };
55462     } catch (std::exception& e) {
55463       {
55464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55465       };
55466     } catch (...) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55469       };
55470     }
55471   }
55472 }
55473
55474
55475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55476   Dali::Application *arg1 = (Dali::Application *) 0 ;
55477
55478   arg1 = (Dali::Application *)jarg1;
55479   {
55480     try {
55481       (arg1)->Quit();
55482     } catch (std::out_of_range& e) {
55483       {
55484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55485       };
55486     } catch (std::exception& e) {
55487       {
55488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55489       };
55490     } catch (...) {
55491       {
55492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55493       };
55494     }
55495   }
55496 }
55497
55498
55499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55500   unsigned int jresult ;
55501   Dali::Application *arg1 = (Dali::Application *) 0 ;
55502   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55503   bool result;
55504
55505   arg1 = (Dali::Application *)jarg1;
55506   arg2 = (Dali::CallbackBase *)jarg2;
55507   {
55508     try {
55509       result = (bool)(arg1)->AddIdle(arg2);
55510     } catch (std::out_of_range& e) {
55511       {
55512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (std::exception& e) {
55515       {
55516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55517       };
55518     } catch (...) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55521       };
55522     }
55523   }
55524   jresult = result;
55525   return jresult;
55526 }
55527
55528
55529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55530   void * jresult ;
55531   Dali::Application *arg1 = (Dali::Application *) 0 ;
55532   Dali::Window result;
55533
55534   arg1 = (Dali::Application *)jarg1;
55535   {
55536     try {
55537       result = (arg1)->GetWindow();
55538     } catch (std::out_of_range& e) {
55539       {
55540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55541       };
55542     } catch (std::exception& e) {
55543       {
55544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (...) {
55547       {
55548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55549       };
55550     }
55551   }
55552   jresult = new Dali::Window((const Dali::Window &)result);
55553   return jresult;
55554 }
55555
55556
55557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55558   Dali::Application *arg1 = (Dali::Application *) 0 ;
55559   Dali::PositionSize arg2 ;
55560   std::string *arg3 = 0 ;
55561   Dali::PositionSize *argp2 ;
55562
55563   arg1 = (Dali::Application *)jarg1;
55564   argp2 = (Dali::PositionSize *)jarg2;
55565   if (!argp2) {
55566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55567     return ;
55568   }
55569   arg2 = *argp2;
55570   if (!jarg3) {
55571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55572     return ;
55573   }
55574   std::string arg3_str(jarg3);
55575   arg3 = &arg3_str;
55576   {
55577     try {
55578       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55579     } catch (std::out_of_range& e) {
55580       {
55581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55582       };
55583     } catch (std::exception& e) {
55584       {
55585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55586       };
55587     } catch (...) {
55588       {
55589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55590       };
55591     }
55592   }
55593
55594   //argout typemap for const std::string&
55595
55596 }
55597
55598
55599 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55600   char * jresult ;
55601   std::string result;
55602
55603   {
55604     try {
55605       result = Dali::Application::GetResourcePath();
55606     } catch (std::out_of_range& e) {
55607       {
55608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55609       };
55610     } catch (std::exception& e) {
55611       {
55612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55613       };
55614     } catch (...) {
55615       {
55616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55617       };
55618     }
55619   }
55620   jresult = SWIG_csharp_string_callback((&result)->c_str());
55621   return jresult;
55622 }
55623
55624
55625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55626   Dali::Application *arg1 = (Dali::Application *) 0 ;
55627   Dali::ViewMode arg2 ;
55628
55629   arg1 = (Dali::Application *)jarg1;
55630   arg2 = (Dali::ViewMode)jarg2;
55631   {
55632     try {
55633       (arg1)->SetViewMode(arg2);
55634     } catch (std::out_of_range& e) {
55635       {
55636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55637       };
55638     } catch (std::exception& e) {
55639       {
55640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55641       };
55642     } catch (...) {
55643       {
55644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55645       };
55646     }
55647   }
55648 }
55649
55650
55651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55652   int jresult ;
55653   Dali::Application *arg1 = (Dali::Application *) 0 ;
55654   Dali::ViewMode result;
55655
55656   arg1 = (Dali::Application *)jarg1;
55657   {
55658     try {
55659       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55660     } catch (std::out_of_range& e) {
55661       {
55662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55663       };
55664     } catch (std::exception& e) {
55665       {
55666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55667       };
55668     } catch (...) {
55669       {
55670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55671       };
55672     }
55673   }
55674   jresult = (int)result;
55675   return jresult;
55676 }
55677
55678
55679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55680   Dali::Application *arg1 = (Dali::Application *) 0 ;
55681   float arg2 ;
55682
55683   arg1 = (Dali::Application *)jarg1;
55684   arg2 = (float)jarg2;
55685   {
55686     try {
55687       (arg1)->SetStereoBase(arg2);
55688     } catch (std::out_of_range& e) {
55689       {
55690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55691       };
55692     } catch (std::exception& e) {
55693       {
55694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55695       };
55696     } catch (...) {
55697       {
55698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55699       };
55700     }
55701   }
55702 }
55703
55704
55705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55706   float jresult ;
55707   Dali::Application *arg1 = (Dali::Application *) 0 ;
55708   float result;
55709
55710   arg1 = (Dali::Application *)jarg1;
55711   {
55712     try {
55713       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55714     } catch (std::out_of_range& e) {
55715       {
55716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55717       };
55718     } catch (std::exception& e) {
55719       {
55720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55721       };
55722     } catch (...) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55725       };
55726     }
55727   }
55728   jresult = result;
55729   return jresult;
55730 }
55731
55732
55733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
55734   void * jresult ;
55735   Dali::Application *arg1 = (Dali::Application *) 0 ;
55736   Dali::Application::AppSignalType *result = 0 ;
55737
55738   arg1 = (Dali::Application *)jarg1;
55739   {
55740     try {
55741       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
55742     } catch (std::out_of_range& e) {
55743       {
55744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55745       };
55746     } catch (std::exception& e) {
55747       {
55748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55749       };
55750     } catch (...) {
55751       {
55752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55753       };
55754     }
55755   }
55756   jresult = (void *)result;
55757   return jresult;
55758 }
55759
55760
55761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
55762   void * jresult ;
55763   Dali::Application *arg1 = (Dali::Application *) 0 ;
55764   Dali::Application::AppSignalType *result = 0 ;
55765
55766   arg1 = (Dali::Application *)jarg1;
55767   {
55768     try {
55769       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
55770     } catch (std::out_of_range& e) {
55771       {
55772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (std::exception& e) {
55775       {
55776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (...) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55781       };
55782     }
55783   }
55784   jresult = (void *)result;
55785   return jresult;
55786 }
55787
55788
55789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
55790   void * jresult ;
55791   Dali::Application *arg1 = (Dali::Application *) 0 ;
55792   Dali::Application::AppSignalType *result = 0 ;
55793
55794   arg1 = (Dali::Application *)jarg1;
55795   {
55796     try {
55797       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
55798     } catch (std::out_of_range& e) {
55799       {
55800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55801       };
55802     } catch (std::exception& e) {
55803       {
55804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55805       };
55806     } catch (...) {
55807       {
55808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55809       };
55810     }
55811   }
55812   jresult = (void *)result;
55813   return jresult;
55814 }
55815
55816
55817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
55818   void * jresult ;
55819   Dali::Application *arg1 = (Dali::Application *) 0 ;
55820   Dali::Application::AppSignalType *result = 0 ;
55821
55822   arg1 = (Dali::Application *)jarg1;
55823   {
55824     try {
55825       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
55826     } catch (std::out_of_range& e) {
55827       {
55828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55829       };
55830     } catch (std::exception& e) {
55831       {
55832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55833       };
55834     } catch (...) {
55835       {
55836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55837       };
55838     }
55839   }
55840   jresult = (void *)result;
55841   return jresult;
55842 }
55843
55844
55845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
55846   void * jresult ;
55847   Dali::Application *arg1 = (Dali::Application *) 0 ;
55848   Dali::Application::AppSignalType *result = 0 ;
55849
55850   arg1 = (Dali::Application *)jarg1;
55851   {
55852     try {
55853       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
55854     } catch (std::out_of_range& e) {
55855       {
55856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55857       };
55858     } catch (std::exception& e) {
55859       {
55860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55861       };
55862     } catch (...) {
55863       {
55864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55865       };
55866     }
55867   }
55868   jresult = (void *)result;
55869   return jresult;
55870 }
55871
55872
55873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
55874   void * jresult ;
55875   Dali::Application *arg1 = (Dali::Application *) 0 ;
55876   Dali::Application::AppSignalType *result = 0 ;
55877
55878   arg1 = (Dali::Application *)jarg1;
55879   {
55880     try {
55881       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55882     } catch (std::out_of_range& e) {
55883       {
55884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55885       };
55886     } catch (std::exception& e) {
55887       {
55888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55889       };
55890     } catch (...) {
55891       {
55892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55893       };
55894     }
55895   }
55896   jresult = (void *)result;
55897   return jresult;
55898 }
55899
55900
55901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55902   void * jresult ;
55903   Dali::Application *arg1 = (Dali::Application *) 0 ;
55904   Dali::Application::AppControlSignalType *result = 0 ;
55905
55906   arg1 = (Dali::Application *)jarg1;
55907   {
55908     try {
55909       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55910     } catch (std::out_of_range& e) {
55911       {
55912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55913       };
55914     } catch (std::exception& e) {
55915       {
55916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55917       };
55918     } catch (...) {
55919       {
55920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55921       };
55922     }
55923   }
55924   jresult = (void *)result;
55925   return jresult;
55926 }
55927
55928
55929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55930   void * jresult ;
55931   Dali::Application *arg1 = (Dali::Application *) 0 ;
55932   Dali::Application::AppSignalType *result = 0 ;
55933
55934   arg1 = (Dali::Application *)jarg1;
55935   {
55936     try {
55937       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55938     } catch (std::out_of_range& e) {
55939       {
55940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (std::exception& e) {
55943       {
55944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55945       };
55946     } catch (...) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55949       };
55950     }
55951   }
55952   jresult = (void *)result;
55953   return jresult;
55954 }
55955
55956
55957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55958   void * jresult ;
55959   Dali::Application *arg1 = (Dali::Application *) 0 ;
55960   Dali::Application::AppSignalType *result = 0 ;
55961
55962   arg1 = (Dali::Application *)jarg1;
55963   {
55964     try {
55965       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55966     } catch (std::out_of_range& e) {
55967       {
55968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55969       };
55970     } catch (std::exception& e) {
55971       {
55972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55973       };
55974     } catch (...) {
55975       {
55976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55977       };
55978     }
55979   }
55980   jresult = (void *)result;
55981   return jresult;
55982 }
55983
55984
55985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55986   void * jresult ;
55987   Dali::Application *arg1 = (Dali::Application *) 0 ;
55988   Dali::Application::AppSignalType *result = 0 ;
55989
55990   arg1 = (Dali::Application *)jarg1;
55991   {
55992     try {
55993       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55994     } catch (std::out_of_range& e) {
55995       {
55996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55997       };
55998     } catch (std::exception& e) {
55999       {
56000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56001       };
56002     } catch (...) {
56003       {
56004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56005       };
56006     }
56007   }
56008   jresult = (void *)result;
56009   return jresult;
56010 }
56011
56012
56013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56014   void * jresult ;
56015   Dali::Application *arg1 = (Dali::Application *) 0 ;
56016   Dali::Application::AppSignalType *result = 0 ;
56017
56018   arg1 = (Dali::Application *)jarg1;
56019   {
56020     try {
56021       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56022     } catch (std::out_of_range& e) {
56023       {
56024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (std::exception& e) {
56027       {
56028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (...) {
56031       {
56032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56033       };
56034     }
56035   }
56036   jresult = (void *)result;
56037   return jresult;
56038 }
56039
56040
56041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56042   unsigned int jresult ;
56043   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56044   bool result;
56045
56046   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56047   {
56048     try {
56049       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56050     } catch (std::out_of_range& e) {
56051       {
56052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56053       };
56054     } catch (std::exception& e) {
56055       {
56056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56061       };
56062     }
56063   }
56064   jresult = result;
56065   return jresult;
56066 }
56067
56068
56069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56070   unsigned long jresult ;
56071   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56072   std::size_t result;
56073
56074   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56075   {
56076     try {
56077       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56078     } catch (std::out_of_range& e) {
56079       {
56080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56081       };
56082     } catch (std::exception& e) {
56083       {
56084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56085       };
56086     } catch (...) {
56087       {
56088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56089       };
56090     }
56091   }
56092   jresult = (unsigned long)result;
56093   return jresult;
56094 }
56095
56096
56097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56098   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56099   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56100
56101   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56102   arg2 = (void (*)(Dali::Application &))jarg2;
56103   {
56104     try {
56105       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (...) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56117       };
56118     }
56119   }
56120 }
56121
56122
56123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56124   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56125   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56126
56127   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56128   arg2 = (void (*)(Dali::Application &))jarg2;
56129   {
56130     try {
56131       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56132     } catch (std::out_of_range& e) {
56133       {
56134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56135       };
56136     } catch (std::exception& e) {
56137       {
56138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56139       };
56140     } catch (...) {
56141       {
56142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56143       };
56144     }
56145   }
56146 }
56147
56148
56149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56150   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56151   Dali::Application *arg2 = 0 ;
56152
56153   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56154   arg2 = (Dali::Application *)jarg2;
56155   if (!arg2) {
56156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56157     return ;
56158   }
56159   {
56160     try {
56161       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56162     } catch (std::out_of_range& e) {
56163       {
56164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56165       };
56166     } catch (std::exception& e) {
56167       {
56168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56169       };
56170     } catch (...) {
56171       {
56172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56173       };
56174     }
56175   }
56176 }
56177
56178
56179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56180   void * jresult ;
56181   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56182
56183   {
56184     try {
56185       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56186     } catch (std::out_of_range& e) {
56187       {
56188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56189       };
56190     } catch (std::exception& e) {
56191       {
56192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56193       };
56194     } catch (...) {
56195       {
56196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56197       };
56198     }
56199   }
56200   jresult = (void *)result;
56201   return jresult;
56202 }
56203
56204
56205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56206   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56207
56208   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56209   {
56210     try {
56211       delete arg1;
56212     } catch (std::out_of_range& e) {
56213       {
56214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56215       };
56216     } catch (std::exception& e) {
56217       {
56218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56219       };
56220     } catch (...) {
56221       {
56222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56223       };
56224     }
56225   }
56226 }
56227
56228
56229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56230   unsigned int jresult ;
56231   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56232   bool result;
56233
56234   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56235   {
56236     try {
56237       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (...) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56249       };
56250     }
56251   }
56252   jresult = result;
56253   return jresult;
56254 }
56255
56256
56257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56258   unsigned long jresult ;
56259   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56260   std::size_t result;
56261
56262   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56263   {
56264     try {
56265       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56266     } catch (std::out_of_range& e) {
56267       {
56268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56269       };
56270     } catch (std::exception& e) {
56271       {
56272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56273       };
56274     } catch (...) {
56275       {
56276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56277       };
56278     }
56279   }
56280   jresult = (unsigned long)result;
56281   return jresult;
56282 }
56283
56284
56285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56286   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56287   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56288
56289   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56290   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56291   {
56292     try {
56293       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56294     } catch (std::out_of_range& e) {
56295       {
56296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56297       };
56298     } catch (std::exception& e) {
56299       {
56300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (...) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56305       };
56306     }
56307   }
56308 }
56309
56310
56311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56312   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56313   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56314
56315   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56316   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56317   {
56318     try {
56319       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56320     } catch (std::out_of_range& e) {
56321       {
56322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56323       };
56324     } catch (std::exception& e) {
56325       {
56326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56327       };
56328     } catch (...) {
56329       {
56330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56331       };
56332     }
56333   }
56334 }
56335
56336
56337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56338   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56339   Dali::Application *arg2 = 0 ;
56340   void *arg3 = (void *) 0 ;
56341
56342   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56343   arg2 = (Dali::Application *)jarg2;
56344   if (!arg2) {
56345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56346     return ;
56347   }
56348   arg3 = jarg3;
56349   {
56350     try {
56351       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56352     } catch (std::out_of_range& e) {
56353       {
56354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56355       };
56356     } catch (std::exception& e) {
56357       {
56358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56359       };
56360     } catch (...) {
56361       {
56362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56363       };
56364     }
56365   }
56366 }
56367
56368
56369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56370   void * jresult ;
56371   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56372
56373   {
56374     try {
56375       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56376     } catch (std::out_of_range& e) {
56377       {
56378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56379       };
56380     } catch (std::exception& e) {
56381       {
56382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56383       };
56384     } catch (...) {
56385       {
56386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56387       };
56388     }
56389   }
56390   jresult = (void *)result;
56391   return jresult;
56392 }
56393
56394
56395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56396   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56397
56398   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56399   {
56400     try {
56401       delete arg1;
56402     } catch (std::out_of_range& e) {
56403       {
56404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56405       };
56406     } catch (std::exception& e) {
56407       {
56408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56409       };
56410     } catch (...) {
56411       {
56412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56413       };
56414     }
56415   }
56416 }
56417
56418
56419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56420   unsigned int jresult ;
56421   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56422   bool result;
56423
56424   arg1 = (Dali::Signal< bool () > *)jarg1;
56425   {
56426     try {
56427       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
56428     } catch (std::out_of_range& e) {
56429       {
56430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (std::exception& e) {
56433       {
56434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (...) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56439       };
56440     }
56441   }
56442   jresult = result;
56443   return jresult;
56444 }
56445
56446
56447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56448   unsigned long jresult ;
56449   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56450   std::size_t result;
56451
56452   arg1 = (Dali::Signal< bool () > *)jarg1;
56453   {
56454     try {
56455       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
56456     } catch (std::out_of_range& e) {
56457       {
56458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56459       };
56460     } catch (std::exception& e) {
56461       {
56462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56463       };
56464     } catch (...) {
56465       {
56466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56467       };
56468     }
56469   }
56470   jresult = (unsigned long)result;
56471   return jresult;
56472 }
56473
56474
56475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
56476   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56477   bool (*arg2)() = (bool (*)()) 0 ;
56478
56479   arg1 = (Dali::Signal< bool () > *)jarg1;
56480   arg2 = (bool (*)())jarg2;
56481   {
56482     try {
56483       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
56484     } catch (std::out_of_range& e) {
56485       {
56486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56487       };
56488     } catch (std::exception& e) {
56489       {
56490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56491       };
56492     } catch (...) {
56493       {
56494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56495       };
56496     }
56497   }
56498 }
56499
56500
56501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56502   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56503   bool (*arg2)() = (bool (*)()) 0 ;
56504
56505   arg1 = (Dali::Signal< bool () > *)jarg1;
56506   arg2 = (bool (*)())jarg2;
56507   {
56508     try {
56509       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
56510     } catch (std::out_of_range& e) {
56511       {
56512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56513       };
56514     } catch (std::exception& e) {
56515       {
56516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56517       };
56518     } catch (...) {
56519       {
56520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56521       };
56522     }
56523   }
56524 }
56525
56526
56527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56528   unsigned int jresult ;
56529   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56530   bool result;
56531
56532   arg1 = (Dali::Signal< bool () > *)jarg1;
56533   {
56534     try {
56535       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56543       };
56544     } catch (...) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56547       };
56548     }
56549   }
56550   jresult = result;
56551   return jresult;
56552 }
56553
56554
56555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56556   void * jresult ;
56557   Dali::Signal< bool () > *result = 0 ;
56558
56559   {
56560     try {
56561       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56562     } catch (std::out_of_range& e) {
56563       {
56564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56565       };
56566     } catch (std::exception& e) {
56567       {
56568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56573       };
56574     }
56575   }
56576   jresult = (void *)result;
56577   return jresult;
56578 }
56579
56580
56581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56582   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56583
56584   arg1 = (Dali::Signal< bool () > *)jarg1;
56585   {
56586     try {
56587       delete arg1;
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56595       };
56596     } catch (...) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56599       };
56600     }
56601   }
56602 }
56603
56604
56605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
56606   unsigned int jresult ;
56607   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56608   bool result;
56609
56610   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56611   {
56612     try {
56613       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
56614     } catch (std::out_of_range& e) {
56615       {
56616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56617       };
56618     } catch (std::exception& e) {
56619       {
56620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56621       };
56622     } catch (...) {
56623       {
56624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56625       };
56626     }
56627   }
56628   jresult = result;
56629   return jresult;
56630 }
56631
56632
56633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
56634   unsigned long jresult ;
56635   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56636   std::size_t result;
56637
56638   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56639   {
56640     try {
56641       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
56642     } catch (std::out_of_range& e) {
56643       {
56644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56645       };
56646     } catch (std::exception& e) {
56647       {
56648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56649       };
56650     } catch (...) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56653       };
56654     }
56655   }
56656   jresult = (unsigned long)result;
56657   return jresult;
56658 }
56659
56660
56661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
56662   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56663   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56664
56665   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56666   arg2 = (void (*)(bool))jarg2;
56667   {
56668     try {
56669       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
56670     } catch (std::out_of_range& e) {
56671       {
56672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56673       };
56674     } catch (std::exception& e) {
56675       {
56676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56677       };
56678     } catch (...) {
56679       {
56680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56681       };
56682     }
56683   }
56684 }
56685
56686
56687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
56688   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56689   void (*arg2)(bool) = (void (*)(bool)) 0 ;
56690
56691   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56692   arg2 = (void (*)(bool))jarg2;
56693   {
56694     try {
56695       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
56696     } catch (std::out_of_range& e) {
56697       {
56698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56699       };
56700     } catch (std::exception& e) {
56701       {
56702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56703       };
56704     } catch (...) {
56705       {
56706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56707       };
56708     }
56709   }
56710 }
56711
56712
56713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
56714   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56715   bool arg2 ;
56716
56717   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56718   arg2 = jarg2 ? true : false;
56719   {
56720     try {
56721       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
56722     } catch (std::out_of_range& e) {
56723       {
56724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56725       };
56726     } catch (std::exception& e) {
56727       {
56728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56729       };
56730     } catch (...) {
56731       {
56732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56733       };
56734     }
56735   }
56736 }
56737
56738
56739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
56740   void * jresult ;
56741   Dali::Signal< void (bool) > *result = 0 ;
56742
56743   {
56744     try {
56745       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
56746     } catch (std::out_of_range& e) {
56747       {
56748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56749       };
56750     } catch (std::exception& e) {
56751       {
56752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (...) {
56755       {
56756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56757       };
56758     }
56759   }
56760   jresult = (void *)result;
56761   return jresult;
56762 }
56763
56764
56765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
56766   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
56767
56768   arg1 = (Dali::Signal< void (bool) > *)jarg1;
56769   {
56770     try {
56771       delete arg1;
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56779       };
56780     } catch (...) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56783       };
56784     }
56785   }
56786 }
56787
56788
56789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56790   int jresult ;
56791   int result;
56792
56793   {
56794     try {
56795       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56796     } catch (std::out_of_range& e) {
56797       {
56798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56799       };
56800     } catch (std::exception& e) {
56801       {
56802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56803       };
56804     } catch (...) {
56805       {
56806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56807       };
56808     }
56809   }
56810   jresult = (int)result;
56811   return jresult;
56812 }
56813
56814
56815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56816   int jresult ;
56817   int result;
56818
56819   {
56820     try {
56821       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56822     } catch (std::out_of_range& e) {
56823       {
56824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56825       };
56826     } catch (std::exception& e) {
56827       {
56828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56829       };
56830     } catch (...) {
56831       {
56832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56833       };
56834     }
56835   }
56836   jresult = (int)result;
56837   return jresult;
56838 }
56839
56840
56841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56842   int jresult ;
56843   int result;
56844
56845   {
56846     try {
56847       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56848     } catch (std::out_of_range& e) {
56849       {
56850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56851       };
56852     } catch (std::exception& e) {
56853       {
56854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56855       };
56856     } catch (...) {
56857       {
56858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56859       };
56860     }
56861   }
56862   jresult = (int)result;
56863   return jresult;
56864 }
56865
56866
56867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56868   int jresult ;
56869   int result;
56870
56871   {
56872     try {
56873       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56874     } catch (std::out_of_range& e) {
56875       {
56876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56877       };
56878     } catch (std::exception& e) {
56879       {
56880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56881       };
56882     } catch (...) {
56883       {
56884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56885       };
56886     }
56887   }
56888   jresult = (int)result;
56889   return jresult;
56890 }
56891
56892
56893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56894   int jresult ;
56895   int result;
56896
56897   {
56898     try {
56899       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56900     } catch (std::out_of_range& e) {
56901       {
56902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (std::exception& e) {
56905       {
56906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56907       };
56908     } catch (...) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56911       };
56912     }
56913   }
56914   jresult = (int)result;
56915   return jresult;
56916 }
56917
56918
56919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56920   int jresult ;
56921   int result;
56922
56923   {
56924     try {
56925       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56926     } catch (std::out_of_range& e) {
56927       {
56928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56929       };
56930     } catch (std::exception& e) {
56931       {
56932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56933       };
56934     } catch (...) {
56935       {
56936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56937       };
56938     }
56939   }
56940   jresult = (int)result;
56941   return jresult;
56942 }
56943
56944
56945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56946   int jresult ;
56947   int result;
56948
56949   {
56950     try {
56951       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (...) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56963       };
56964     }
56965   }
56966   jresult = (int)result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56972   int jresult ;
56973   int result;
56974
56975   {
56976     try {
56977       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56978     } catch (std::out_of_range& e) {
56979       {
56980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56981       };
56982     } catch (std::exception& e) {
56983       {
56984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56985       };
56986     } catch (...) {
56987       {
56988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56989       };
56990     }
56991   }
56992   jresult = (int)result;
56993   return jresult;
56994 }
56995
56996
56997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56998   int jresult ;
56999   int result;
57000
57001   {
57002     try {
57003       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57004     } catch (std::out_of_range& e) {
57005       {
57006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57007       };
57008     } catch (std::exception& e) {
57009       {
57010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57011       };
57012     } catch (...) {
57013       {
57014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57015       };
57016     }
57017   }
57018   jresult = (int)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57024   int jresult ;
57025   int result;
57026
57027   {
57028     try {
57029       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57030     } catch (std::out_of_range& e) {
57031       {
57032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57033       };
57034     } catch (std::exception& e) {
57035       {
57036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57037       };
57038     } catch (...) {
57039       {
57040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57041       };
57042     }
57043   }
57044   jresult = (int)result;
57045   return jresult;
57046 }
57047
57048
57049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57050   int jresult ;
57051   int result;
57052
57053   {
57054     try {
57055       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57056     } catch (std::out_of_range& e) {
57057       {
57058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57059       };
57060     } catch (std::exception& e) {
57061       {
57062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57063       };
57064     } catch (...) {
57065       {
57066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57067       };
57068     }
57069   }
57070   jresult = (int)result;
57071   return jresult;
57072 }
57073
57074
57075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57076   int jresult ;
57077   int result;
57078
57079   {
57080     try {
57081       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57082     } catch (std::out_of_range& e) {
57083       {
57084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57085       };
57086     } catch (std::exception& e) {
57087       {
57088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (...) {
57091       {
57092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57093       };
57094     }
57095   }
57096   jresult = (int)result;
57097   return jresult;
57098 }
57099
57100
57101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57102   int jresult ;
57103   int result;
57104
57105   {
57106     try {
57107       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57108     } catch (std::out_of_range& e) {
57109       {
57110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (std::exception& e) {
57113       {
57114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57115       };
57116     } catch (...) {
57117       {
57118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57119       };
57120     }
57121   }
57122   jresult = (int)result;
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57128   int jresult ;
57129   int result;
57130
57131   {
57132     try {
57133       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57134     } catch (std::out_of_range& e) {
57135       {
57136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57137       };
57138     } catch (std::exception& e) {
57139       {
57140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57141       };
57142     } catch (...) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57145       };
57146     }
57147   }
57148   jresult = (int)result;
57149   return jresult;
57150 }
57151
57152
57153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57154   int jresult ;
57155   int result;
57156
57157   {
57158     try {
57159       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57160     } catch (std::out_of_range& e) {
57161       {
57162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (std::exception& e) {
57165       {
57166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (...) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57171       };
57172     }
57173   }
57174   jresult = (int)result;
57175   return jresult;
57176 }
57177
57178
57179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57180   int jresult ;
57181   int result;
57182
57183   {
57184     try {
57185       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57193       };
57194     } catch (...) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57197       };
57198     }
57199   }
57200   jresult = (int)result;
57201   return jresult;
57202 }
57203
57204
57205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57206   int jresult ;
57207   int result;
57208
57209   {
57210     try {
57211       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57212     } catch (std::out_of_range& e) {
57213       {
57214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57215       };
57216     } catch (std::exception& e) {
57217       {
57218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57219       };
57220     } catch (...) {
57221       {
57222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57223       };
57224     }
57225   }
57226   jresult = (int)result;
57227   return jresult;
57228 }
57229
57230
57231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57232   int jresult ;
57233   int result;
57234
57235   {
57236     try {
57237       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57238     } catch (std::out_of_range& e) {
57239       {
57240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57241       };
57242     } catch (std::exception& e) {
57243       {
57244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57245       };
57246     } catch (...) {
57247       {
57248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57249       };
57250     }
57251   }
57252   jresult = (int)result;
57253   return jresult;
57254 }
57255
57256
57257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57258   int jresult ;
57259   int result;
57260
57261   {
57262     try {
57263       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57264     } catch (std::out_of_range& e) {
57265       {
57266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57267       };
57268     } catch (std::exception& e) {
57269       {
57270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57271       };
57272     } catch (...) {
57273       {
57274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57275       };
57276     }
57277   }
57278   jresult = (int)result;
57279   return jresult;
57280 }
57281
57282
57283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57284   int jresult ;
57285   int result;
57286
57287   {
57288     try {
57289       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57297       };
57298     } catch (...) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57301       };
57302     }
57303   }
57304   jresult = (int)result;
57305   return jresult;
57306 }
57307
57308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57309   int jresult ;
57310   int result;
57311
57312   {
57313     try {
57314       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
57315     } catch (std::out_of_range& e) {
57316       {
57317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (std::exception& e) {
57320       {
57321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57326       };
57327     }
57328   }
57329   jresult = (int)result;
57330   return jresult;
57331 }
57332
57333
57334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57335   int jresult ;
57336   int result;
57337
57338   {
57339     try {
57340       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57341     } catch (std::out_of_range& e) {
57342       {
57343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57344       };
57345     } catch (std::exception& e) {
57346       {
57347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57348       };
57349     } catch (...) {
57350       {
57351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57352       };
57353     }
57354   }
57355   jresult = (int)result;
57356   return jresult;
57357 }
57358
57359
57360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57361   int jresult ;
57362   int result;
57363
57364   {
57365     try {
57366       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57367     } catch (std::out_of_range& e) {
57368       {
57369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57370       };
57371     } catch (std::exception& e) {
57372       {
57373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57374       };
57375     } catch (...) {
57376       {
57377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57378       };
57379     }
57380   }
57381   jresult = (int)result;
57382   return jresult;
57383 }
57384
57385
57386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57387   int jresult ;
57388   int result;
57389
57390   {
57391     try {
57392       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57393     } catch (std::out_of_range& e) {
57394       {
57395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (std::exception& e) {
57398       {
57399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57404       };
57405     }
57406   }
57407   jresult = (int)result;
57408   return jresult;
57409 }
57410
57411
57412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57413   int jresult ;
57414   int result;
57415
57416   {
57417     try {
57418       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57419     } catch (std::out_of_range& e) {
57420       {
57421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57422       };
57423     } catch (std::exception& e) {
57424       {
57425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57426       };
57427     } catch (...) {
57428       {
57429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57430       };
57431     }
57432   }
57433   jresult = (int)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57439   int jresult ;
57440   int result;
57441
57442   {
57443     try {
57444       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57445     } catch (std::out_of_range& e) {
57446       {
57447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57448       };
57449     } catch (std::exception& e) {
57450       {
57451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57452       };
57453     } catch (...) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57456       };
57457     }
57458   }
57459   jresult = (int)result;
57460   return jresult;
57461 }
57462
57463
57464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57465   int jresult ;
57466   int result;
57467
57468   {
57469     try {
57470       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57471     } catch (std::out_of_range& e) {
57472       {
57473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57474       };
57475     } catch (std::exception& e) {
57476       {
57477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57478       };
57479     } catch (...) {
57480       {
57481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57482       };
57483     }
57484   }
57485   jresult = (int)result;
57486   return jresult;
57487 }
57488
57489
57490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57491   int jresult ;
57492   int result;
57493
57494   {
57495     try {
57496       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57497     } catch (std::out_of_range& e) {
57498       {
57499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57500       };
57501     } catch (std::exception& e) {
57502       {
57503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57504       };
57505     } catch (...) {
57506       {
57507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57508       };
57509     }
57510   }
57511   jresult = (int)result;
57512   return jresult;
57513 }
57514
57515
57516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57517   int jresult ;
57518   int result;
57519
57520   {
57521     try {
57522       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57530       };
57531     } catch (...) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57534       };
57535     }
57536   }
57537   jresult = (int)result;
57538   return jresult;
57539 }
57540
57541
57542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57543   int jresult ;
57544   int result;
57545
57546   {
57547     try {
57548       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57549     } catch (std::out_of_range& e) {
57550       {
57551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57552       };
57553     } catch (std::exception& e) {
57554       {
57555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (...) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57560       };
57561     }
57562   }
57563   jresult = (int)result;
57564   return jresult;
57565 }
57566
57567
57568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57569   int jresult ;
57570   int result;
57571
57572   {
57573     try {
57574       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57575     } catch (std::out_of_range& e) {
57576       {
57577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57578       };
57579     } catch (std::exception& e) {
57580       {
57581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57582       };
57583     } catch (...) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57586       };
57587     }
57588   }
57589   jresult = (int)result;
57590   return jresult;
57591 }
57592
57593
57594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57595   int jresult ;
57596   int result;
57597
57598   {
57599     try {
57600       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57601     } catch (std::out_of_range& e) {
57602       {
57603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57604       };
57605     } catch (std::exception& e) {
57606       {
57607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57608       };
57609     } catch (...) {
57610       {
57611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57612       };
57613     }
57614   }
57615   jresult = (int)result;
57616   return jresult;
57617 }
57618
57619
57620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57621   int jresult ;
57622   int result;
57623
57624   {
57625     try {
57626       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57627     } catch (std::out_of_range& e) {
57628       {
57629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57630       };
57631     } catch (std::exception& e) {
57632       {
57633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57638       };
57639     }
57640   }
57641   jresult = (int)result;
57642   return jresult;
57643 }
57644
57645
57646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57647   int jresult ;
57648   int result;
57649
57650   {
57651     try {
57652       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57653     } catch (std::out_of_range& e) {
57654       {
57655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57656       };
57657     } catch (std::exception& e) {
57658       {
57659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57660       };
57661     } catch (...) {
57662       {
57663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57664       };
57665     }
57666   }
57667   jresult = (int)result;
57668   return jresult;
57669 }
57670
57671
57672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57673   int jresult ;
57674   int result;
57675
57676   {
57677     try {
57678       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57679     } catch (std::out_of_range& e) {
57680       {
57681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57682       };
57683     } catch (std::exception& e) {
57684       {
57685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57686       };
57687     } catch (...) {
57688       {
57689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57690       };
57691     }
57692   }
57693   jresult = (int)result;
57694   return jresult;
57695 }
57696
57697
57698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57699   int jresult ;
57700   int result;
57701
57702   {
57703     try {
57704       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57705     } catch (std::out_of_range& e) {
57706       {
57707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57708       };
57709     } catch (std::exception& e) {
57710       {
57711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57712       };
57713     } catch (...) {
57714       {
57715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57716       };
57717     }
57718   }
57719   jresult = (int)result;
57720   return jresult;
57721 }
57722
57723
57724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57725   int jresult ;
57726   int result;
57727
57728   {
57729     try {
57730       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57731     } catch (std::out_of_range& e) {
57732       {
57733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57734       };
57735     } catch (std::exception& e) {
57736       {
57737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57738       };
57739     } catch (...) {
57740       {
57741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57742       };
57743     }
57744   }
57745   jresult = (int)result;
57746   return jresult;
57747 }
57748
57749
57750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57751   int jresult ;
57752   int result;
57753
57754   {
57755     try {
57756       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57757     } catch (std::out_of_range& e) {
57758       {
57759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (std::exception& e) {
57762       {
57763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (...) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57768       };
57769     }
57770   }
57771   jresult = (int)result;
57772   return jresult;
57773 }
57774
57775
57776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57777   int jresult ;
57778   int result;
57779
57780   {
57781     try {
57782       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (...) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57794       };
57795     }
57796   }
57797   jresult = (int)result;
57798   return jresult;
57799 }
57800
57801
57802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57803   int jresult ;
57804   int result;
57805
57806   {
57807     try {
57808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57809     } catch (std::out_of_range& e) {
57810       {
57811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57812       };
57813     } catch (std::exception& e) {
57814       {
57815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57820       };
57821     }
57822   }
57823   jresult = (int)result;
57824   return jresult;
57825 }
57826
57827
57828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57829   int jresult ;
57830   int result;
57831
57832   {
57833     try {
57834       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (...) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57846       };
57847     }
57848   }
57849   jresult = (int)result;
57850   return jresult;
57851 }
57852
57853
57854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57855   int jresult ;
57856   int result;
57857
57858   {
57859     try {
57860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57861     } catch (std::out_of_range& e) {
57862       {
57863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57864       };
57865     } catch (std::exception& e) {
57866       {
57867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57868       };
57869     } catch (...) {
57870       {
57871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57872       };
57873     }
57874   }
57875   jresult = (int)result;
57876   return jresult;
57877 }
57878
57879
57880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57881   int jresult ;
57882   int result;
57883
57884   {
57885     try {
57886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57887     } catch (std::out_of_range& e) {
57888       {
57889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57890       };
57891     } catch (std::exception& e) {
57892       {
57893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57894       };
57895     } catch (...) {
57896       {
57897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57898       };
57899     }
57900   }
57901   jresult = (int)result;
57902   return jresult;
57903 }
57904
57905
57906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57907   int jresult ;
57908   int result;
57909
57910   {
57911     try {
57912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (...) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57924       };
57925     }
57926   }
57927   jresult = (int)result;
57928   return jresult;
57929 }
57930
57931
57932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57933   int jresult ;
57934   int result;
57935
57936   {
57937     try {
57938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57946       };
57947     } catch (...) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57950       };
57951     }
57952   }
57953   jresult = (int)result;
57954   return jresult;
57955 }
57956
57957
57958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57959   int jresult ;
57960   int result;
57961
57962   {
57963     try {
57964       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57965     } catch (std::out_of_range& e) {
57966       {
57967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57968       };
57969     } catch (std::exception& e) {
57970       {
57971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57972       };
57973     } catch (...) {
57974       {
57975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57976       };
57977     }
57978   }
57979   jresult = (int)result;
57980   return jresult;
57981 }
57982
57983
57984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57985   int jresult ;
57986   int result;
57987
57988   {
57989     try {
57990       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57991     } catch (std::out_of_range& e) {
57992       {
57993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57994       };
57995     } catch (std::exception& e) {
57996       {
57997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57998       };
57999     } catch (...) {
58000       {
58001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58002       };
58003     }
58004   }
58005   jresult = (int)result;
58006   return jresult;
58007 }
58008
58009
58010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58011   int jresult ;
58012   int result;
58013
58014   {
58015     try {
58016       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58017     } catch (std::out_of_range& e) {
58018       {
58019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58020       };
58021     } catch (std::exception& e) {
58022       {
58023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58024       };
58025     } catch (...) {
58026       {
58027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58028       };
58029     }
58030   }
58031   jresult = (int)result;
58032   return jresult;
58033 }
58034
58035
58036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58037   int jresult ;
58038   int result;
58039
58040   {
58041     try {
58042       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58043     } catch (std::out_of_range& e) {
58044       {
58045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (std::exception& e) {
58048       {
58049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58050       };
58051     } catch (...) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58054       };
58055     }
58056   }
58057   jresult = (int)result;
58058   return jresult;
58059 }
58060
58061
58062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58063   int jresult ;
58064   int result;
58065
58066   {
58067     try {
58068       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58069     } catch (std::out_of_range& e) {
58070       {
58071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58072       };
58073     } catch (std::exception& e) {
58074       {
58075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58076       };
58077     } catch (...) {
58078       {
58079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58080       };
58081     }
58082   }
58083   jresult = (int)result;
58084   return jresult;
58085 }
58086
58087
58088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58089   int jresult ;
58090   int result;
58091
58092   {
58093     try {
58094       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58095     } catch (std::out_of_range& e) {
58096       {
58097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (std::exception& e) {
58100       {
58101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58102       };
58103     } catch (...) {
58104       {
58105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58106       };
58107     }
58108   }
58109   jresult = (int)result;
58110   return jresult;
58111 }
58112
58113
58114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58115   int jresult ;
58116   int result;
58117
58118   {
58119     try {
58120       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58121     } catch (std::out_of_range& e) {
58122       {
58123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58124       };
58125     } catch (std::exception& e) {
58126       {
58127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58128       };
58129     } catch (...) {
58130       {
58131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58132       };
58133     }
58134   }
58135   jresult = (int)result;
58136   return jresult;
58137 }
58138
58139
58140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58141   int jresult ;
58142   int result;
58143
58144   {
58145     try {
58146       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58147     } catch (std::out_of_range& e) {
58148       {
58149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58150       };
58151     } catch (std::exception& e) {
58152       {
58153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58154       };
58155     } catch (...) {
58156       {
58157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58158       };
58159     }
58160   }
58161   jresult = (int)result;
58162   return jresult;
58163 }
58164
58165
58166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58167   int jresult ;
58168   int result;
58169
58170   {
58171     try {
58172       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58173     } catch (std::out_of_range& e) {
58174       {
58175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58176       };
58177     } catch (std::exception& e) {
58178       {
58179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58180       };
58181     } catch (...) {
58182       {
58183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58184       };
58185     }
58186   }
58187   jresult = (int)result;
58188   return jresult;
58189 }
58190
58191
58192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58193   int jresult ;
58194   int result;
58195
58196   {
58197     try {
58198       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58199     } catch (std::out_of_range& e) {
58200       {
58201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58202       };
58203     } catch (std::exception& e) {
58204       {
58205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58206       };
58207     } catch (...) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58210       };
58211     }
58212   }
58213   jresult = (int)result;
58214   return jresult;
58215 }
58216
58217
58218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58219   int jresult ;
58220   int result;
58221
58222   {
58223     try {
58224       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (...) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58236       };
58237     }
58238   }
58239   jresult = (int)result;
58240   return jresult;
58241 }
58242
58243
58244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58245   int jresult ;
58246   int result;
58247
58248   {
58249     try {
58250       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58251     } catch (std::out_of_range& e) {
58252       {
58253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58254       };
58255     } catch (std::exception& e) {
58256       {
58257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58258       };
58259     } catch (...) {
58260       {
58261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58262       };
58263     }
58264   }
58265   jresult = (int)result;
58266   return jresult;
58267 }
58268
58269
58270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58271   int jresult ;
58272   int result;
58273
58274   {
58275     try {
58276       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58277     } catch (std::out_of_range& e) {
58278       {
58279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58280       };
58281     } catch (std::exception& e) {
58282       {
58283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58284       };
58285     } catch (...) {
58286       {
58287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58288       };
58289     }
58290   }
58291   jresult = (int)result;
58292   return jresult;
58293 }
58294
58295
58296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58297   void * jresult ;
58298   Dali::Toolkit::Builder *result = 0 ;
58299
58300   {
58301     try {
58302       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58303     } catch (std::out_of_range& e) {
58304       {
58305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (std::exception& e) {
58308       {
58309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (...) {
58312       {
58313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58314       };
58315     }
58316   }
58317   jresult = (void *)result;
58318   return jresult;
58319 }
58320
58321
58322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58323   void * jresult ;
58324   Dali::Toolkit::Builder result;
58325
58326   {
58327     try {
58328       result = Dali::Toolkit::Builder::New();
58329     } catch (std::out_of_range& e) {
58330       {
58331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58332       };
58333     } catch (std::exception& e) {
58334       {
58335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58336       };
58337     } catch (...) {
58338       {
58339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58340       };
58341     }
58342   }
58343   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58344   return jresult;
58345 }
58346
58347
58348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58349   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58350
58351   arg1 = (Dali::Toolkit::Builder *)jarg1;
58352   {
58353     try {
58354       delete arg1;
58355     } catch (std::out_of_range& e) {
58356       {
58357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58358       };
58359     } catch (std::exception& e) {
58360       {
58361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58362       };
58363     } catch (...) {
58364       {
58365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58366       };
58367     }
58368   }
58369 }
58370
58371
58372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58373   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58374   std::string *arg2 = 0 ;
58375   Dali::Toolkit::Builder::UIFormat arg3 ;
58376
58377   arg1 = (Dali::Toolkit::Builder *)jarg1;
58378   if (!jarg2) {
58379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58380     return ;
58381   }
58382   std::string arg2_str(jarg2);
58383   arg2 = &arg2_str;
58384   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58385   {
58386     try {
58387       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58388     } catch (std::out_of_range& e) {
58389       {
58390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58391       };
58392     } catch (std::exception& e) {
58393       {
58394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58395       };
58396     } catch (...) {
58397       {
58398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58399       };
58400     }
58401   }
58402
58403   //argout typemap for const std::string&
58404
58405 }
58406
58407
58408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58409   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58410   std::string *arg2 = 0 ;
58411
58412   arg1 = (Dali::Toolkit::Builder *)jarg1;
58413   if (!jarg2) {
58414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58415     return ;
58416   }
58417   std::string arg2_str(jarg2);
58418   arg2 = &arg2_str;
58419   {
58420     try {
58421       (arg1)->LoadFromString((std::string const &)*arg2);
58422     } catch (std::out_of_range& e) {
58423       {
58424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58425       };
58426     } catch (std::exception& e) {
58427       {
58428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58429       };
58430     } catch (...) {
58431       {
58432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58433       };
58434     }
58435   }
58436
58437   //argout typemap for const std::string&
58438
58439 }
58440
58441
58442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58443   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58444   Dali::Property::Map *arg2 = 0 ;
58445
58446   arg1 = (Dali::Toolkit::Builder *)jarg1;
58447   arg2 = (Dali::Property::Map *)jarg2;
58448   if (!arg2) {
58449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58450     return ;
58451   }
58452   {
58453     try {
58454       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58455     } catch (std::out_of_range& e) {
58456       {
58457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58458       };
58459     } catch (std::exception& e) {
58460       {
58461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58462       };
58463     } catch (...) {
58464       {
58465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58466       };
58467     }
58468   }
58469 }
58470
58471
58472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58473   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58474   std::string *arg2 = 0 ;
58475   Dali::Property::Value *arg3 = 0 ;
58476
58477   arg1 = (Dali::Toolkit::Builder *)jarg1;
58478   if (!jarg2) {
58479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58480     return ;
58481   }
58482   std::string arg2_str(jarg2);
58483   arg2 = &arg2_str;
58484   arg3 = (Dali::Property::Value *)jarg3;
58485   if (!arg3) {
58486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58487     return ;
58488   }
58489   {
58490     try {
58491       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
58492     } catch (std::out_of_range& e) {
58493       {
58494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58495       };
58496     } catch (std::exception& e) {
58497       {
58498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58499       };
58500     } catch (...) {
58501       {
58502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58503       };
58504     }
58505   }
58506
58507   //argout typemap for const std::string&
58508
58509 }
58510
58511
58512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58513   void * jresult ;
58514   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58515   Dali::Property::Map *result = 0 ;
58516
58517   arg1 = (Dali::Toolkit::Builder *)jarg1;
58518   {
58519     try {
58520       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58521     } catch (std::out_of_range& e) {
58522       {
58523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58524       };
58525     } catch (std::exception& e) {
58526       {
58527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58528       };
58529     } catch (...) {
58530       {
58531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58532       };
58533     }
58534   }
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58541   void * jresult ;
58542   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58543   std::string *arg2 = 0 ;
58544   Dali::Property::Value *result = 0 ;
58545
58546   arg1 = (Dali::Toolkit::Builder *)jarg1;
58547   if (!jarg2) {
58548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58549     return 0;
58550   }
58551   std::string arg2_str(jarg2);
58552   arg2 = &arg2_str;
58553   {
58554     try {
58555       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58556     } catch (std::out_of_range& e) {
58557       {
58558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58559       };
58560     } catch (std::exception& e) {
58561       {
58562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58563       };
58564     } catch (...) {
58565       {
58566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58567       };
58568     }
58569   }
58570   jresult = (void *)result;
58571
58572   //argout typemap for const std::string&
58573
58574   return jresult;
58575 }
58576
58577
58578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58579   void * jresult ;
58580   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58581   std::string *arg2 = 0 ;
58582   Dali::Animation result;
58583
58584   arg1 = (Dali::Toolkit::Builder *)jarg1;
58585   if (!jarg2) {
58586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58587     return 0;
58588   }
58589   std::string arg2_str(jarg2);
58590   arg2 = &arg2_str;
58591   {
58592     try {
58593       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58594     } catch (std::out_of_range& e) {
58595       {
58596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58597       };
58598     } catch (std::exception& e) {
58599       {
58600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58601       };
58602     } catch (...) {
58603       {
58604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58605       };
58606     }
58607   }
58608   jresult = new Dali::Animation((const Dali::Animation &)result);
58609
58610   //argout typemap for const std::string&
58611
58612   return jresult;
58613 }
58614
58615
58616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58617   void * jresult ;
58618   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58619   std::string *arg2 = 0 ;
58620   Dali::Property::Map *arg3 = 0 ;
58621   Dali::Animation result;
58622
58623   arg1 = (Dali::Toolkit::Builder *)jarg1;
58624   if (!jarg2) {
58625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58626     return 0;
58627   }
58628   std::string arg2_str(jarg2);
58629   arg2 = &arg2_str;
58630   arg3 = (Dali::Property::Map *)jarg3;
58631   if (!arg3) {
58632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58633     return 0;
58634   }
58635   {
58636     try {
58637       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58638     } catch (std::out_of_range& e) {
58639       {
58640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58641       };
58642     } catch (std::exception& e) {
58643       {
58644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58645       };
58646     } catch (...) {
58647       {
58648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58649       };
58650     }
58651   }
58652   jresult = new Dali::Animation((const Dali::Animation &)result);
58653
58654   //argout typemap for const std::string&
58655
58656   return jresult;
58657 }
58658
58659
58660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58661   void * jresult ;
58662   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58663   std::string *arg2 = 0 ;
58664   Dali::Actor arg3 ;
58665   Dali::Actor *argp3 ;
58666   Dali::Animation result;
58667
58668   arg1 = (Dali::Toolkit::Builder *)jarg1;
58669   if (!jarg2) {
58670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58671     return 0;
58672   }
58673   std::string arg2_str(jarg2);
58674   arg2 = &arg2_str;
58675   argp3 = (Dali::Actor *)jarg3;
58676   if (!argp3) {
58677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58678     return 0;
58679   }
58680   arg3 = *argp3;
58681   {
58682     try {
58683       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58684     } catch (std::out_of_range& e) {
58685       {
58686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58687       };
58688     } catch (std::exception& e) {
58689       {
58690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58691       };
58692     } catch (...) {
58693       {
58694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58695       };
58696     }
58697   }
58698   jresult = new Dali::Animation((const Dali::Animation &)result);
58699
58700   //argout typemap for const std::string&
58701
58702   return jresult;
58703 }
58704
58705
58706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58707   void * jresult ;
58708   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58709   std::string *arg2 = 0 ;
58710   Dali::Property::Map *arg3 = 0 ;
58711   Dali::Actor arg4 ;
58712   Dali::Actor *argp4 ;
58713   Dali::Animation result;
58714
58715   arg1 = (Dali::Toolkit::Builder *)jarg1;
58716   if (!jarg2) {
58717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58718     return 0;
58719   }
58720   std::string arg2_str(jarg2);
58721   arg2 = &arg2_str;
58722   arg3 = (Dali::Property::Map *)jarg3;
58723   if (!arg3) {
58724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58725     return 0;
58726   }
58727   argp4 = (Dali::Actor *)jarg4;
58728   if (!argp4) {
58729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58730     return 0;
58731   }
58732   arg4 = *argp4;
58733   {
58734     try {
58735       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58736     } catch (std::out_of_range& e) {
58737       {
58738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58739       };
58740     } catch (std::exception& e) {
58741       {
58742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58743       };
58744     } catch (...) {
58745       {
58746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58747       };
58748     }
58749   }
58750   jresult = new Dali::Animation((const Dali::Animation &)result);
58751
58752   //argout typemap for const std::string&
58753
58754   return jresult;
58755 }
58756
58757
58758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58759   void * jresult ;
58760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58761   std::string *arg2 = 0 ;
58762   Dali::BaseHandle result;
58763
58764   arg1 = (Dali::Toolkit::Builder *)jarg1;
58765   if (!jarg2) {
58766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58767     return 0;
58768   }
58769   std::string arg2_str(jarg2);
58770   arg2 = &arg2_str;
58771   {
58772     try {
58773       result = (arg1)->Create((std::string const &)*arg2);
58774     } catch (std::out_of_range& e) {
58775       {
58776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58777       };
58778     } catch (std::exception& e) {
58779       {
58780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58781       };
58782     } catch (...) {
58783       {
58784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58785       };
58786     }
58787   }
58788   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58789
58790   //argout typemap for const std::string&
58791
58792   return jresult;
58793 }
58794
58795
58796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58797   void * jresult ;
58798   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58799   std::string *arg2 = 0 ;
58800   Dali::Property::Map *arg3 = 0 ;
58801   Dali::BaseHandle result;
58802
58803   arg1 = (Dali::Toolkit::Builder *)jarg1;
58804   if (!jarg2) {
58805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58806     return 0;
58807   }
58808   std::string arg2_str(jarg2);
58809   arg2 = &arg2_str;
58810   arg3 = (Dali::Property::Map *)jarg3;
58811   if (!arg3) {
58812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58813     return 0;
58814   }
58815   {
58816     try {
58817       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58818     } catch (std::out_of_range& e) {
58819       {
58820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (std::exception& e) {
58823       {
58824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (...) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58829       };
58830     }
58831   }
58832   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58833
58834   //argout typemap for const std::string&
58835
58836   return jresult;
58837 }
58838
58839
58840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58841   void * jresult ;
58842   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58843   std::string *arg2 = 0 ;
58844   Dali::BaseHandle result;
58845
58846   arg1 = (Dali::Toolkit::Builder *)jarg1;
58847   if (!jarg2) {
58848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58849     return 0;
58850   }
58851   std::string arg2_str(jarg2);
58852   arg2 = &arg2_str;
58853   {
58854     try {
58855       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58856     } catch (std::out_of_range& e) {
58857       {
58858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58859       };
58860     } catch (std::exception& e) {
58861       {
58862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (...) {
58865       {
58866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58867       };
58868     }
58869   }
58870   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58871
58872   //argout typemap for const std::string&
58873
58874   return jresult;
58875 }
58876
58877
58878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58879   unsigned int jresult ;
58880   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58881   std::string *arg2 = 0 ;
58882   Dali::Handle *arg3 = 0 ;
58883   bool result;
58884
58885   arg1 = (Dali::Toolkit::Builder *)jarg1;
58886   if (!jarg2) {
58887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58888     return 0;
58889   }
58890   std::string arg2_str(jarg2);
58891   arg2 = &arg2_str;
58892   arg3 = (Dali::Handle *)jarg3;
58893   if (!arg3) {
58894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58895     return 0;
58896   }
58897   {
58898     try {
58899       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58900     } catch (std::out_of_range& e) {
58901       {
58902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58903       };
58904     } catch (std::exception& e) {
58905       {
58906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58907       };
58908     } catch (...) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58911       };
58912     }
58913   }
58914   jresult = result;
58915
58916   //argout typemap for const std::string&
58917
58918   return jresult;
58919 }
58920
58921
58922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58923   unsigned int jresult ;
58924   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58925   Dali::Handle *arg2 = 0 ;
58926   std::string *arg3 = 0 ;
58927   bool result;
58928
58929   arg1 = (Dali::Toolkit::Builder *)jarg1;
58930   arg2 = (Dali::Handle *)jarg2;
58931   if (!arg2) {
58932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58933     return 0;
58934   }
58935   if (!jarg3) {
58936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58937     return 0;
58938   }
58939   std::string arg3_str(jarg3);
58940   arg3 = &arg3_str;
58941   {
58942     try {
58943       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58944     } catch (std::out_of_range& e) {
58945       {
58946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58947       };
58948     } catch (std::exception& e) {
58949       {
58950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58951       };
58952     } catch (...) {
58953       {
58954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58955       };
58956     }
58957   }
58958   jresult = result;
58959
58960   //argout typemap for const std::string&
58961
58962   return jresult;
58963 }
58964
58965
58966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58967   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58968   Dali::Actor arg2 ;
58969   Dali::Actor *argp2 ;
58970
58971   arg1 = (Dali::Toolkit::Builder *)jarg1;
58972   argp2 = (Dali::Actor *)jarg2;
58973   if (!argp2) {
58974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58975     return ;
58976   }
58977   arg2 = *argp2;
58978   {
58979     try {
58980       (arg1)->AddActors(arg2);
58981     } catch (std::out_of_range& e) {
58982       {
58983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58984       };
58985     } catch (std::exception& e) {
58986       {
58987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58988       };
58989     } catch (...) {
58990       {
58991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58992       };
58993     }
58994   }
58995 }
58996
58997
58998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58999   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59000   std::string *arg2 = 0 ;
59001   Dali::Actor arg3 ;
59002   Dali::Actor *argp3 ;
59003
59004   arg1 = (Dali::Toolkit::Builder *)jarg1;
59005   if (!jarg2) {
59006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59007     return ;
59008   }
59009   std::string arg2_str(jarg2);
59010   arg2 = &arg2_str;
59011   argp3 = (Dali::Actor *)jarg3;
59012   if (!argp3) {
59013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59014     return ;
59015   }
59016   arg3 = *argp3;
59017   {
59018     try {
59019       (arg1)->AddActors((std::string const &)*arg2,arg3);
59020     } catch (std::out_of_range& e) {
59021       {
59022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59023       };
59024     } catch (std::exception& e) {
59025       {
59026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59027       };
59028     } catch (...) {
59029       {
59030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59031       };
59032     }
59033   }
59034
59035   //argout typemap for const std::string&
59036
59037 }
59038
59039
59040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59041   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59042   std::string *arg2 = 0 ;
59043
59044   arg1 = (Dali::Toolkit::Builder *)jarg1;
59045   if (!jarg2) {
59046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59047     return ;
59048   }
59049   std::string arg2_str(jarg2);
59050   arg2 = &arg2_str;
59051   {
59052     try {
59053       (arg1)->CreateRenderTask((std::string const &)*arg2);
59054     } catch (std::out_of_range& e) {
59055       {
59056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59057       };
59058     } catch (std::exception& e) {
59059       {
59060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59061       };
59062     } catch (...) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59065       };
59066     }
59067   }
59068
59069   //argout typemap for const std::string&
59070
59071 }
59072
59073
59074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59075   void * jresult ;
59076   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59077   std::string *arg2 = 0 ;
59078   Dali::FrameBufferImage result;
59079
59080   arg1 = (Dali::Toolkit::Builder *)jarg1;
59081   if (!jarg2) {
59082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59083     return 0;
59084   }
59085   std::string arg2_str(jarg2);
59086   arg2 = &arg2_str;
59087   {
59088     try {
59089       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59090     } catch (std::out_of_range& e) {
59091       {
59092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59093       };
59094     } catch (std::exception& e) {
59095       {
59096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (...) {
59099       {
59100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59101       };
59102     }
59103   }
59104   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59105
59106   //argout typemap for const std::string&
59107
59108   return jresult;
59109 }
59110
59111
59112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59113   void * jresult ;
59114   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59115   std::string *arg2 = 0 ;
59116   Dali::Path result;
59117
59118   arg1 = (Dali::Toolkit::Builder *)jarg1;
59119   if (!jarg2) {
59120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59121     return 0;
59122   }
59123   std::string arg2_str(jarg2);
59124   arg2 = &arg2_str;
59125   {
59126     try {
59127       result = (arg1)->GetPath((std::string const &)*arg2);
59128     } catch (std::out_of_range& e) {
59129       {
59130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59131       };
59132     } catch (std::exception& e) {
59133       {
59134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59135       };
59136     } catch (...) {
59137       {
59138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59139       };
59140     }
59141   }
59142   jresult = new Dali::Path((const Dali::Path &)result);
59143
59144   //argout typemap for const std::string&
59145
59146   return jresult;
59147 }
59148
59149
59150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59151   void * jresult ;
59152   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59153   std::string *arg2 = 0 ;
59154   Dali::PathConstrainer result;
59155
59156   arg1 = (Dali::Toolkit::Builder *)jarg1;
59157   if (!jarg2) {
59158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59159     return 0;
59160   }
59161   std::string arg2_str(jarg2);
59162   arg2 = &arg2_str;
59163   {
59164     try {
59165       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59166     } catch (std::out_of_range& e) {
59167       {
59168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59169       };
59170     } catch (std::exception& e) {
59171       {
59172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59173       };
59174     } catch (...) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59177       };
59178     }
59179   }
59180   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59181
59182   //argout typemap for const std::string&
59183
59184   return jresult;
59185 }
59186
59187
59188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59189   void * jresult ;
59190   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59191   std::string *arg2 = 0 ;
59192   Dali::LinearConstrainer result;
59193
59194   arg1 = (Dali::Toolkit::Builder *)jarg1;
59195   if (!jarg2) {
59196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59197     return 0;
59198   }
59199   std::string arg2_str(jarg2);
59200   arg2 = &arg2_str;
59201   {
59202     try {
59203       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59204     } catch (std::out_of_range& e) {
59205       {
59206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59207       };
59208     } catch (std::exception& e) {
59209       {
59210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59211       };
59212     } catch (...) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59215       };
59216     }
59217   }
59218   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59219
59220   //argout typemap for const std::string&
59221
59222   return jresult;
59223 }
59224
59225
59226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59227   void * jresult ;
59228   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59229   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59230
59231   arg1 = (Dali::Toolkit::Builder *)jarg1;
59232   {
59233     try {
59234       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59235     } catch (std::out_of_range& e) {
59236       {
59237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (std::exception& e) {
59240       {
59241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (...) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59246       };
59247     }
59248   }
59249   jresult = (void *)result;
59250   return jresult;
59251 }
59252
59253
59254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59255   void * jresult ;
59256   Dali::Toolkit::TransitionData *result = 0 ;
59257
59258   {
59259     try {
59260       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59261     } catch (std::out_of_range& e) {
59262       {
59263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59264       };
59265     } catch (std::exception& e) {
59266       {
59267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59268       };
59269     } catch (...) {
59270       {
59271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59272       };
59273     }
59274   }
59275   jresult = (void *)result;
59276   return jresult;
59277 }
59278
59279
59280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59281   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59282
59283   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59284   {
59285     try {
59286       delete arg1;
59287     } catch (std::out_of_range& e) {
59288       {
59289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59290       };
59291     } catch (std::exception& e) {
59292       {
59293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59294       };
59295     } catch (...) {
59296       {
59297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59298       };
59299     }
59300   }
59301 }
59302
59303
59304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59305   void * jresult ;
59306   Dali::Property::Map *arg1 = 0 ;
59307   Dali::Toolkit::TransitionData result;
59308
59309   arg1 = (Dali::Property::Map *)jarg1;
59310   if (!arg1) {
59311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59312     return 0;
59313   }
59314   {
59315     try {
59316       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59328       };
59329     }
59330   }
59331   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59332   return jresult;
59333 }
59334
59335
59336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59337   void * jresult ;
59338   Dali::Property::Array *arg1 = 0 ;
59339   Dali::Toolkit::TransitionData result;
59340
59341   arg1 = (Dali::Property::Array *)jarg1;
59342   if (!arg1) {
59343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59344     return 0;
59345   }
59346   {
59347     try {
59348       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59349     } catch (std::out_of_range& e) {
59350       {
59351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59352       };
59353     } catch (std::exception& e) {
59354       {
59355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59356       };
59357     } catch (...) {
59358       {
59359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59360       };
59361     }
59362   }
59363   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59364   return jresult;
59365 }
59366
59367
59368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59369   void * jresult ;
59370   Dali::BaseHandle arg1 ;
59371   Dali::BaseHandle *argp1 ;
59372   Dali::Toolkit::TransitionData result;
59373
59374   argp1 = (Dali::BaseHandle *)jarg1;
59375   if (!argp1) {
59376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59377     return 0;
59378   }
59379   arg1 = *argp1;
59380   {
59381     try {
59382       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59383     } catch (std::out_of_range& e) {
59384       {
59385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (std::exception& e) {
59388       {
59389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59390       };
59391     } catch (...) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59394       };
59395     }
59396   }
59397   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59398   return jresult;
59399 }
59400
59401
59402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59403   void * jresult ;
59404   Dali::Toolkit::TransitionData *arg1 = 0 ;
59405   Dali::Toolkit::TransitionData *result = 0 ;
59406
59407   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59408   if (!arg1) {
59409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59410     return 0;
59411   }
59412   {
59413     try {
59414       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59415     } catch (std::out_of_range& e) {
59416       {
59417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59418       };
59419     } catch (std::exception& e) {
59420       {
59421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59422       };
59423     } catch (...) {
59424       {
59425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59426       };
59427     }
59428   }
59429   jresult = (void *)result;
59430   return jresult;
59431 }
59432
59433
59434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59435   void * jresult ;
59436   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59437   Dali::Toolkit::TransitionData *arg2 = 0 ;
59438   Dali::Toolkit::TransitionData *result = 0 ;
59439
59440   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59441   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59442   if (!arg2) {
59443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59444     return 0;
59445   }
59446   {
59447     try {
59448       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59449     } catch (std::out_of_range& e) {
59450       {
59451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59452       };
59453     } catch (std::exception& e) {
59454       {
59455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59456       };
59457     } catch (...) {
59458       {
59459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59460       };
59461     }
59462   }
59463   jresult = (void *)result;
59464   return jresult;
59465 }
59466
59467
59468 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59469   unsigned long jresult ;
59470   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59471   size_t result;
59472
59473   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59474   {
59475     try {
59476       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59477     } catch (std::out_of_range& e) {
59478       {
59479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59480       };
59481     } catch (std::exception& e) {
59482       {
59483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59484       };
59485     } catch (...) {
59486       {
59487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59488       };
59489     }
59490   }
59491   jresult = (unsigned long)result;
59492   return jresult;
59493 }
59494
59495
59496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59497   void * jresult ;
59498   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59499   size_t arg2 ;
59500   Dali::Property::Map result;
59501
59502   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59503   arg2 = (size_t)jarg2;
59504   {
59505     try {
59506       result = (arg1)->GetAnimatorAt(arg2);
59507     } catch (std::out_of_range& e) {
59508       {
59509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (std::exception& e) {
59512       {
59513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59514       };
59515     } catch (...) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59518       };
59519     }
59520   }
59521   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59522   return jresult;
59523 }
59524
59525
59526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59527   void * jresult ;
59528   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59529   Dali::Toolkit::TransitionData *result = 0 ;
59530
59531   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59532   {
59533     try {
59534       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59535     } catch (std::out_of_range& e) {
59536       {
59537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (std::exception& e) {
59540       {
59541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59542       };
59543     } catch (...) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59546       };
59547     }
59548   }
59549   jresult = (void *)result;
59550   return jresult;
59551 }
59552
59553
59554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59555   int jresult ;
59556   int result;
59557
59558   {
59559     try {
59560       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59561     } catch (std::out_of_range& e) {
59562       {
59563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (std::exception& e) {
59566       {
59567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (...) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59572       };
59573     }
59574   }
59575   jresult = (int)result;
59576   return jresult;
59577 }
59578
59579
59580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59581   int jresult ;
59582   int result;
59583
59584   {
59585     try {
59586       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59587     } catch (std::out_of_range& e) {
59588       {
59589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (std::exception& e) {
59592       {
59593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (...) {
59596       {
59597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59598       };
59599     }
59600   }
59601   jresult = (int)result;
59602   return jresult;
59603 }
59604
59605
59606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59607   int jresult ;
59608   int result;
59609
59610   {
59611     try {
59612       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59613     } catch (std::out_of_range& e) {
59614       {
59615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59616       };
59617     } catch (std::exception& e) {
59618       {
59619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59620       };
59621     } catch (...) {
59622       {
59623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59624       };
59625     }
59626   }
59627   jresult = (int)result;
59628   return jresult;
59629 }
59630
59631
59632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59633   int jresult ;
59634   int result;
59635
59636   {
59637     try {
59638       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59639     } catch (std::out_of_range& e) {
59640       {
59641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59642       };
59643     } catch (std::exception& e) {
59644       {
59645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59646       };
59647     } catch (...) {
59648       {
59649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59650       };
59651     }
59652   }
59653   jresult = (int)result;
59654   return jresult;
59655 }
59656
59657
59658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59659   int jresult ;
59660   int result;
59661
59662   {
59663     try {
59664       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59665     } catch (std::out_of_range& e) {
59666       {
59667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (std::exception& e) {
59670       {
59671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59676       };
59677     }
59678   }
59679   jresult = (int)result;
59680   return jresult;
59681 }
59682
59683
59684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59685   int jresult ;
59686   int result;
59687
59688   {
59689     try {
59690       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705   jresult = (int)result;
59706   return jresult;
59707 }
59708
59709
59710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59711   int jresult ;
59712   int result;
59713
59714   {
59715     try {
59716       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59717     } catch (std::out_of_range& e) {
59718       {
59719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (std::exception& e) {
59722       {
59723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (...) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59728       };
59729     }
59730   }
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59737   int jresult ;
59738   int result;
59739
59740   {
59741     try {
59742       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (...) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59754       };
59755     }
59756   }
59757   jresult = (int)result;
59758   return jresult;
59759 }
59760
59761
59762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59763   int jresult ;
59764   int result;
59765
59766   {
59767     try {
59768       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59769     } catch (std::out_of_range& e) {
59770       {
59771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59772       };
59773     } catch (std::exception& e) {
59774       {
59775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (...) {
59778       {
59779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59780       };
59781     }
59782   }
59783   jresult = (int)result;
59784   return jresult;
59785 }
59786
59787
59788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59789   int jresult ;
59790   int result;
59791
59792   {
59793     try {
59794       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59795     } catch (std::out_of_range& e) {
59796       {
59797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59798       };
59799     } catch (std::exception& e) {
59800       {
59801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59802       };
59803     } catch (...) {
59804       {
59805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59806       };
59807     }
59808   }
59809   jresult = (int)result;
59810   return jresult;
59811 }
59812
59813
59814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59815   int jresult ;
59816   int result;
59817
59818   {
59819     try {
59820       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59821     } catch (std::out_of_range& e) {
59822       {
59823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59824       };
59825     } catch (std::exception& e) {
59826       {
59827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (...) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59832       };
59833     }
59834   }
59835   jresult = (int)result;
59836   return jresult;
59837 }
59838
59839
59840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59841   int jresult ;
59842   int result;
59843
59844   {
59845     try {
59846       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59847     } catch (std::out_of_range& e) {
59848       {
59849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59850       };
59851     } catch (std::exception& e) {
59852       {
59853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (...) {
59856       {
59857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59858       };
59859     }
59860   }
59861   jresult = (int)result;
59862   return jresult;
59863 }
59864
59865
59866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59867   int jresult ;
59868   int result;
59869
59870   {
59871     try {
59872       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59873     } catch (std::out_of_range& e) {
59874       {
59875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59876       };
59877     } catch (std::exception& e) {
59878       {
59879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59880       };
59881     } catch (...) {
59882       {
59883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59884       };
59885     }
59886   }
59887   jresult = (int)result;
59888   return jresult;
59889 }
59890
59891
59892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59893   int jresult ;
59894   int result;
59895
59896   {
59897     try {
59898       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59899     } catch (std::out_of_range& e) {
59900       {
59901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59902       };
59903     } catch (std::exception& e) {
59904       {
59905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59906       };
59907     } catch (...) {
59908       {
59909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59910       };
59911     }
59912   }
59913   jresult = (int)result;
59914   return jresult;
59915 }
59916
59917
59918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59919   void * jresult ;
59920   Dali::Toolkit::Control result;
59921
59922   {
59923     try {
59924       result = Dali::Toolkit::Internal::Control::New();
59925     } catch (std::out_of_range& e) {
59926       {
59927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59928       };
59929     } catch (std::exception& e) {
59930       {
59931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (...) {
59934       {
59935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59936       };
59937     }
59938   }
59939   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59940   return jresult;
59941 }
59942
59943
59944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59946   std::string *arg2 = 0 ;
59947
59948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59949   if (!jarg2) {
59950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59951     return ;
59952   }
59953   std::string arg2_str(jarg2);
59954   arg2 = &arg2_str;
59955   {
59956     try {
59957       (arg1)->SetStyleName((std::string const &)*arg2);
59958     } catch (std::out_of_range& e) {
59959       {
59960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59961       };
59962     } catch (std::exception& e) {
59963       {
59964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59965       };
59966     } catch (...) {
59967       {
59968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59969       };
59970     }
59971   }
59972
59973   //argout typemap for const std::string&
59974
59975 }
59976
59977
59978 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59979   char * jresult ;
59980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59981   std::string *result = 0 ;
59982
59983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59984   {
59985     try {
59986       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59987     } catch (std::out_of_range& e) {
59988       {
59989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59990       };
59991     } catch (std::exception& e) {
59992       {
59993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59994       };
59995     } catch (...) {
59996       {
59997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59998       };
59999     }
60000   }
60001   jresult = SWIG_csharp_string_callback(result->c_str());
60002   return jresult;
60003 }
60004
60005
60006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60008   Dali::Vector4 *arg2 = 0 ;
60009
60010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60011   arg2 = (Dali::Vector4 *)jarg2;
60012   if (!arg2) {
60013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60014     return ;
60015   }
60016   {
60017     try {
60018       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60019     } catch (std::out_of_range& e) {
60020       {
60021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60022       };
60023     } catch (std::exception& e) {
60024       {
60025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60026       };
60027     } catch (...) {
60028       {
60029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60030       };
60031     }
60032   }
60033 }
60034
60035
60036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60037   void * jresult ;
60038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60039   Dali::Vector4 result;
60040
60041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60042   {
60043     try {
60044       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60045     } catch (std::out_of_range& e) {
60046       {
60047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60048       };
60049     } catch (std::exception& e) {
60050       {
60051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60052       };
60053     } catch (...) {
60054       {
60055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60056       };
60057     }
60058   }
60059   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60060   return jresult;
60061 }
60062
60063
60064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60066   Dali::Image arg2 ;
60067   Dali::Image *argp2 ;
60068
60069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60070   argp2 = (Dali::Image *)jarg2;
60071   if (!argp2) {
60072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60073     return ;
60074   }
60075   arg2 = *argp2;
60076   {
60077     try {
60078       (arg1)->SetBackgroundImage(arg2);
60079     } catch (std::out_of_range& e) {
60080       {
60081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60082       };
60083     } catch (std::exception& e) {
60084       {
60085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60086       };
60087     } catch (...) {
60088       {
60089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60090       };
60091     }
60092   }
60093 }
60094
60095
60096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60098   Dali::Property::Map *arg2 = 0 ;
60099
60100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60101   arg2 = (Dali::Property::Map *)jarg2;
60102   if (!arg2) {
60103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60104     return ;
60105   }
60106   {
60107     try {
60108       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60109     } catch (std::out_of_range& e) {
60110       {
60111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60112       };
60113     } catch (std::exception& e) {
60114       {
60115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60116       };
60117     } catch (...) {
60118       {
60119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60120       };
60121     }
60122   }
60123 }
60124
60125
60126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60128
60129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60130   {
60131     try {
60132       (arg1)->ClearBackground();
60133     } catch (std::out_of_range& e) {
60134       {
60135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60136       };
60137     } catch (std::exception& e) {
60138       {
60139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60140       };
60141     } catch (...) {
60142       {
60143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60144       };
60145     }
60146   }
60147 }
60148
60149
60150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60152   Dali::Gesture::Type arg2 ;
60153
60154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60155   arg2 = (Dali::Gesture::Type)jarg2;
60156   {
60157     try {
60158       (arg1)->EnableGestureDetection(arg2);
60159     } catch (std::out_of_range& e) {
60160       {
60161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60162       };
60163     } catch (std::exception& e) {
60164       {
60165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60166       };
60167     } catch (...) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60170       };
60171     }
60172   }
60173 }
60174
60175
60176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60178   Dali::Gesture::Type arg2 ;
60179
60180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60181   arg2 = (Dali::Gesture::Type)jarg2;
60182   {
60183     try {
60184       (arg1)->DisableGestureDetection(arg2);
60185     } catch (std::out_of_range& e) {
60186       {
60187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60188       };
60189     } catch (std::exception& e) {
60190       {
60191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60192       };
60193     } catch (...) {
60194       {
60195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60196       };
60197     }
60198   }
60199 }
60200
60201
60202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60203   void * jresult ;
60204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60205   Dali::PinchGestureDetector result;
60206
60207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60208   {
60209     try {
60210       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60211     } catch (std::out_of_range& e) {
60212       {
60213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (std::exception& e) {
60216       {
60217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (...) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60222       };
60223     }
60224   }
60225   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60226   return jresult;
60227 }
60228
60229
60230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60231   void * jresult ;
60232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60233   Dali::PanGestureDetector result;
60234
60235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60236   {
60237     try {
60238       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60239     } catch (std::out_of_range& e) {
60240       {
60241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60242       };
60243     } catch (std::exception& e) {
60244       {
60245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (...) {
60248       {
60249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60250       };
60251     }
60252   }
60253   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60254   return jresult;
60255 }
60256
60257
60258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60259   void * jresult ;
60260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60261   Dali::TapGestureDetector result;
60262
60263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60264   {
60265     try {
60266       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60267     } catch (std::out_of_range& e) {
60268       {
60269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60270       };
60271     } catch (std::exception& e) {
60272       {
60273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60274       };
60275     } catch (...) {
60276       {
60277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60278       };
60279     }
60280   }
60281   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60282   return jresult;
60283 }
60284
60285
60286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60287   void * jresult ;
60288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60289   Dali::LongPressGestureDetector result;
60290
60291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60292   {
60293     try {
60294       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60295     } catch (std::out_of_range& e) {
60296       {
60297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60298       };
60299     } catch (std::exception& e) {
60300       {
60301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60302       };
60303     } catch (...) {
60304       {
60305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60306       };
60307     }
60308   }
60309   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60310   return jresult;
60311 }
60312
60313
60314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60316   bool arg2 ;
60317
60318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60319   arg2 = jarg2 ? true : false;
60320   {
60321     try {
60322       (arg1)->SetKeyboardNavigationSupport(arg2);
60323     } catch (std::out_of_range& e) {
60324       {
60325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60326       };
60327     } catch (std::exception& e) {
60328       {
60329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60330       };
60331     } catch (...) {
60332       {
60333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60334       };
60335     }
60336   }
60337 }
60338
60339
60340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60341   unsigned int jresult ;
60342   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60343   bool result;
60344
60345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60346   {
60347     try {
60348       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60349     } catch (std::out_of_range& e) {
60350       {
60351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60352       };
60353     } catch (std::exception& e) {
60354       {
60355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60356       };
60357     } catch (...) {
60358       {
60359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60360       };
60361     }
60362   }
60363   jresult = result;
60364   return jresult;
60365 }
60366
60367
60368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60370
60371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60372   {
60373     try {
60374       (arg1)->SetKeyInputFocus();
60375     } catch (std::out_of_range& e) {
60376       {
60377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60378       };
60379     } catch (std::exception& e) {
60380       {
60381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60382       };
60383     } catch (...) {
60384       {
60385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60386       };
60387     }
60388   }
60389 }
60390
60391
60392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60393   unsigned int jresult ;
60394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60395   bool result;
60396
60397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60398   {
60399     try {
60400       result = (bool)(arg1)->HasKeyInputFocus();
60401     } catch (std::out_of_range& e) {
60402       {
60403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60404       };
60405     } catch (std::exception& e) {
60406       {
60407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60412       };
60413     }
60414   }
60415   jresult = result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60422
60423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60424   {
60425     try {
60426       (arg1)->ClearKeyInputFocus();
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60434       };
60435     } catch (...) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60438       };
60439     }
60440   }
60441 }
60442
60443
60444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60445   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60446   bool arg2 ;
60447
60448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60449   arg2 = jarg2 ? true : false;
60450   {
60451     try {
60452       (arg1)->SetAsKeyboardFocusGroup(arg2);
60453     } catch (std::out_of_range& e) {
60454       {
60455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60456       };
60457     } catch (std::exception& e) {
60458       {
60459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60460       };
60461     } catch (...) {
60462       {
60463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60464       };
60465     }
60466   }
60467 }
60468
60469
60470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60471   unsigned int jresult ;
60472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60473   bool result;
60474
60475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60476   {
60477     try {
60478       result = (bool)(arg1)->IsKeyboardFocusGroup();
60479     } catch (std::out_of_range& e) {
60480       {
60481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60482       };
60483     } catch (std::exception& e) {
60484       {
60485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60486       };
60487     } catch (...) {
60488       {
60489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60490       };
60491     }
60492   }
60493   jresult = result;
60494   return jresult;
60495 }
60496
60497
60498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60500
60501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60502   {
60503     try {
60504       (arg1)->AccessibilityActivate();
60505     } catch (std::out_of_range& e) {
60506       {
60507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60508       };
60509     } catch (std::exception& e) {
60510       {
60511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60512       };
60513     } catch (...) {
60514       {
60515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60516       };
60517     }
60518   }
60519 }
60520
60521
60522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60523   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60524
60525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60526   {
60527     try {
60528       (arg1)->KeyboardEnter();
60529     } catch (std::out_of_range& e) {
60530       {
60531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60532       };
60533     } catch (std::exception& e) {
60534       {
60535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60536       };
60537     } catch (...) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60540       };
60541     }
60542   }
60543 }
60544
60545
60546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60547   void * jresult ;
60548   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60549   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60550
60551   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60552   {
60553     try {
60554       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60555     } catch (std::out_of_range& e) {
60556       {
60557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (std::exception& e) {
60560       {
60561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (...) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60566       };
60567     }
60568   }
60569   jresult = (void *)result;
60570   return jresult;
60571 }
60572
60573
60574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60575   void * jresult ;
60576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60577   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60578
60579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60580   {
60581     try {
60582       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60583     } catch (std::out_of_range& e) {
60584       {
60585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60586       };
60587     } catch (std::exception& e) {
60588       {
60589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60590       };
60591     } catch (...) {
60592       {
60593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60594       };
60595     }
60596   }
60597   jresult = (void *)result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60603   void * jresult ;
60604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60605   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60606
60607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60608   {
60609     try {
60610       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60611     } catch (std::out_of_range& e) {
60612       {
60613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (std::exception& e) {
60616       {
60617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625   jresult = (void *)result;
60626   return jresult;
60627 }
60628
60629
60630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60631   unsigned int jresult ;
60632   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60633   Dali::KeyEvent *arg2 = 0 ;
60634   bool result;
60635
60636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60637   arg2 = (Dali::KeyEvent *)jarg2;
60638   if (!arg2) {
60639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60640     return 0;
60641   }
60642   {
60643     try {
60644       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60645     } catch (std::out_of_range& e) {
60646       {
60647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60648       };
60649     } catch (std::exception& e) {
60650       {
60651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60652       };
60653     } catch (...) {
60654       {
60655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60656       };
60657     }
60658   }
60659   jresult = result;
60660   return jresult;
60661 }
60662
60663
60664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60665   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60666   int arg2 ;
60667   SwigDirector_ViewImpl *darg = 0;
60668
60669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60670   arg2 = (int)jarg2;
60671   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60672   {
60673     try {
60674       (darg)->OnStageConnection(arg2);
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60686       };
60687     }
60688   }
60689 }
60690
60691
60692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60694   int arg2 ;
60695   SwigDirector_ViewImpl *darg = 0;
60696
60697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60698   arg2 = (int)jarg2;
60699   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60700   {
60701     try {
60702       (darg)->OnStageConnectionSwigPublic(arg2);
60703     } catch (std::out_of_range& e) {
60704       {
60705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60706       };
60707     } catch (std::exception& e) {
60708       {
60709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60710       };
60711     } catch (...) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60714       };
60715     }
60716   }
60717 }
60718
60719
60720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60722   SwigDirector_ViewImpl *darg = 0;
60723
60724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60726   {
60727     try {
60728       (darg)->OnStageDisconnection();
60729     } catch (std::out_of_range& e) {
60730       {
60731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60732       };
60733     } catch (std::exception& e) {
60734       {
60735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60736       };
60737     } catch (...) {
60738       {
60739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60740       };
60741     }
60742   }
60743 }
60744
60745
60746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60748   SwigDirector_ViewImpl *darg = 0;
60749
60750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60752   {
60753     try {
60754       (darg)->OnStageDisconnectionSwigPublic();
60755     } catch (std::out_of_range& e) {
60756       {
60757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60758       };
60759     } catch (std::exception& e) {
60760       {
60761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60766       };
60767     }
60768   }
60769 }
60770
60771
60772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60774   Dali::Actor *arg2 = 0 ;
60775   SwigDirector_ViewImpl *darg = 0;
60776
60777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60778   arg2 = (Dali::Actor *)jarg2;
60779   if (!arg2) {
60780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60781     return ;
60782   }
60783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60784   {
60785     try {
60786       (darg)->OnChildAdd(*arg2);
60787     } catch (std::out_of_range& e) {
60788       {
60789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60790       };
60791     } catch (std::exception& e) {
60792       {
60793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60794       };
60795     } catch (...) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60798       };
60799     }
60800   }
60801 }
60802
60803
60804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60806   Dali::Actor *arg2 = 0 ;
60807   SwigDirector_ViewImpl *darg = 0;
60808
60809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60810   arg2 = (Dali::Actor *)jarg2;
60811   if (!arg2) {
60812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60813     return ;
60814   }
60815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60816   {
60817     try {
60818       (darg)->OnChildAddSwigPublic(*arg2);
60819     } catch (std::out_of_range& e) {
60820       {
60821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60822       };
60823     } catch (std::exception& e) {
60824       {
60825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60826       };
60827     } catch (...) {
60828       {
60829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60830       };
60831     }
60832   }
60833 }
60834
60835
60836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60837   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60838   Dali::Actor *arg2 = 0 ;
60839   SwigDirector_ViewImpl *darg = 0;
60840
60841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60842   arg2 = (Dali::Actor *)jarg2;
60843   if (!arg2) {
60844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60845     return ;
60846   }
60847   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60848   {
60849     try {
60850       (darg)->OnChildRemove(*arg2);
60851     } catch (std::out_of_range& e) {
60852       {
60853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60854       };
60855     } catch (std::exception& e) {
60856       {
60857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60858       };
60859     } catch (...) {
60860       {
60861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60862       };
60863     }
60864   }
60865 }
60866
60867
60868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60870   Dali::Actor *arg2 = 0 ;
60871   SwigDirector_ViewImpl *darg = 0;
60872
60873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60874   arg2 = (Dali::Actor *)jarg2;
60875   if (!arg2) {
60876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60877     return ;
60878   }
60879   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60880   {
60881     try {
60882       (darg)->OnChildRemoveSwigPublic(*arg2);
60883     } catch (std::out_of_range& e) {
60884       {
60885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60886       };
60887     } catch (std::exception& e) {
60888       {
60889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60890       };
60891     } catch (...) {
60892       {
60893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60894       };
60895     }
60896   }
60897 }
60898
60899
60900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60902   Dali::Property::Index arg2 ;
60903   Dali::Property::Value arg3 ;
60904   Dali::Property::Value *argp3 ;
60905   SwigDirector_ViewImpl *darg = 0;
60906
60907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60908   arg2 = (Dali::Property::Index)jarg2;
60909   argp3 = (Dali::Property::Value *)jarg3;
60910   if (!argp3) {
60911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60912     return ;
60913   }
60914   arg3 = *argp3;
60915   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60916   {
60917     try {
60918       (darg)->OnPropertySet(arg2,arg3);
60919     } catch (std::out_of_range& e) {
60920       {
60921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60922       };
60923     } catch (std::exception& e) {
60924       {
60925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60926       };
60927     } catch (...) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60930       };
60931     }
60932   }
60933 }
60934
60935
60936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60938   Dali::Property::Index arg2 ;
60939   Dali::Property::Value arg3 ;
60940   Dali::Property::Value *argp3 ;
60941   SwigDirector_ViewImpl *darg = 0;
60942
60943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60944   arg2 = (Dali::Property::Index)jarg2;
60945   argp3 = (Dali::Property::Value *)jarg3;
60946   if (!argp3) {
60947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60948     return ;
60949   }
60950   arg3 = *argp3;
60951   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60952   {
60953     try {
60954       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60955     } catch (std::out_of_range& e) {
60956       {
60957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60958       };
60959     } catch (std::exception& e) {
60960       {
60961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60962       };
60963     } catch (...) {
60964       {
60965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60966       };
60967     }
60968   }
60969 }
60970
60971
60972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60974   Dali::Vector3 *arg2 = 0 ;
60975   SwigDirector_ViewImpl *darg = 0;
60976
60977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60978   arg2 = (Dali::Vector3 *)jarg2;
60979   if (!arg2) {
60980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60981     return ;
60982   }
60983   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60984   {
60985     try {
60986       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60987     } catch (std::out_of_range& e) {
60988       {
60989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60990       };
60991     } catch (std::exception& e) {
60992       {
60993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60994       };
60995     } catch (...) {
60996       {
60997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60998       };
60999     }
61000   }
61001 }
61002
61003
61004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61006   Dali::Vector3 *arg2 = 0 ;
61007   SwigDirector_ViewImpl *darg = 0;
61008
61009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61010   arg2 = (Dali::Vector3 *)jarg2;
61011   if (!arg2) {
61012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61013     return ;
61014   }
61015   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61016   {
61017     try {
61018       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61019     } catch (std::out_of_range& e) {
61020       {
61021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61022       };
61023     } catch (std::exception& e) {
61024       {
61025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61026       };
61027     } catch (...) {
61028       {
61029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61030       };
61031     }
61032   }
61033 }
61034
61035
61036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61038   Dali::Animation *arg2 = 0 ;
61039   Dali::Vector3 *arg3 = 0 ;
61040   SwigDirector_ViewImpl *darg = 0;
61041
61042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61043   arg2 = (Dali::Animation *)jarg2;
61044   if (!arg2) {
61045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61046     return ;
61047   }
61048   arg3 = (Dali::Vector3 *)jarg3;
61049   if (!arg3) {
61050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61051     return ;
61052   }
61053   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61054   {
61055     try {
61056       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61057     } catch (std::out_of_range& e) {
61058       {
61059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61060       };
61061     } catch (std::exception& e) {
61062       {
61063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61064       };
61065     } catch (...) {
61066       {
61067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61068       };
61069     }
61070   }
61071 }
61072
61073
61074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61076   Dali::Animation *arg2 = 0 ;
61077   Dali::Vector3 *arg3 = 0 ;
61078   SwigDirector_ViewImpl *darg = 0;
61079
61080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61081   arg2 = (Dali::Animation *)jarg2;
61082   if (!arg2) {
61083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61084     return ;
61085   }
61086   arg3 = (Dali::Vector3 *)jarg3;
61087   if (!arg3) {
61088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61089     return ;
61090   }
61091   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61092   {
61093     try {
61094       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61095     } catch (std::out_of_range& e) {
61096       {
61097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61098       };
61099     } catch (std::exception& e) {
61100       {
61101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61102       };
61103     } catch (...) {
61104       {
61105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61106       };
61107     }
61108   }
61109 }
61110
61111
61112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61113   unsigned int jresult ;
61114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61115   Dali::TouchEvent *arg2 = 0 ;
61116   SwigDirector_ViewImpl *darg = 0;
61117   bool result;
61118
61119   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61120   arg2 = (Dali::TouchEvent *)jarg2;
61121   if (!arg2) {
61122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61123     return 0;
61124   }
61125   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61126   {
61127     try {
61128       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61129     } catch (std::out_of_range& e) {
61130       {
61131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61132       };
61133     } catch (std::exception& e) {
61134       {
61135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61136       };
61137     } catch (...) {
61138       {
61139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61140       };
61141     }
61142   }
61143   jresult = result;
61144   return jresult;
61145 }
61146
61147
61148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61149   unsigned int jresult ;
61150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61151   Dali::TouchEvent *arg2 = 0 ;
61152   SwigDirector_ViewImpl *darg = 0;
61153   bool result;
61154
61155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61156   arg2 = (Dali::TouchEvent *)jarg2;
61157   if (!arg2) {
61158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61159     return 0;
61160   }
61161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61162   {
61163     try {
61164       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61165     } catch (std::out_of_range& e) {
61166       {
61167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61168       };
61169     } catch (std::exception& e) {
61170       {
61171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (...) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61176       };
61177     }
61178   }
61179   jresult = result;
61180   return jresult;
61181 }
61182
61183
61184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61185   unsigned int jresult ;
61186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61187   Dali::HoverEvent *arg2 = 0 ;
61188   SwigDirector_ViewImpl *darg = 0;
61189   bool result;
61190
61191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61192   arg2 = (Dali::HoverEvent *)jarg2;
61193   if (!arg2) {
61194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61195     return 0;
61196   }
61197   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61198   {
61199     try {
61200       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61201     } catch (std::out_of_range& e) {
61202       {
61203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61204       };
61205     } catch (std::exception& e) {
61206       {
61207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61208       };
61209     } catch (...) {
61210       {
61211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61212       };
61213     }
61214   }
61215   jresult = result;
61216   return jresult;
61217 }
61218
61219
61220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61221   unsigned int jresult ;
61222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61223   Dali::HoverEvent *arg2 = 0 ;
61224   SwigDirector_ViewImpl *darg = 0;
61225   bool result;
61226
61227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61228   arg2 = (Dali::HoverEvent *)jarg2;
61229   if (!arg2) {
61230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61231     return 0;
61232   }
61233   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61234   {
61235     try {
61236       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61237     } catch (std::out_of_range& e) {
61238       {
61239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61240       };
61241     } catch (std::exception& e) {
61242       {
61243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61244       };
61245     } catch (...) {
61246       {
61247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61248       };
61249     }
61250   }
61251   jresult = result;
61252   return jresult;
61253 }
61254
61255
61256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61257   unsigned int jresult ;
61258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61259   Dali::KeyEvent *arg2 = 0 ;
61260   SwigDirector_ViewImpl *darg = 0;
61261   bool result;
61262
61263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61264   arg2 = (Dali::KeyEvent *)jarg2;
61265   if (!arg2) {
61266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61267     return 0;
61268   }
61269   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61270   {
61271     try {
61272       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61273     } catch (std::out_of_range& e) {
61274       {
61275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61276       };
61277     } catch (std::exception& e) {
61278       {
61279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61280       };
61281     } catch (...) {
61282       {
61283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61284       };
61285     }
61286   }
61287   jresult = result;
61288   return jresult;
61289 }
61290
61291
61292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61293   unsigned int jresult ;
61294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61295   Dali::KeyEvent *arg2 = 0 ;
61296   SwigDirector_ViewImpl *darg = 0;
61297   bool result;
61298
61299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61300   arg2 = (Dali::KeyEvent *)jarg2;
61301   if (!arg2) {
61302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61303     return 0;
61304   }
61305   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61306   {
61307     try {
61308       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61309     } catch (std::out_of_range& e) {
61310       {
61311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61312       };
61313     } catch (std::exception& e) {
61314       {
61315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61316       };
61317     } catch (...) {
61318       {
61319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61320       };
61321     }
61322   }
61323   jresult = result;
61324   return jresult;
61325 }
61326
61327
61328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61329   unsigned int jresult ;
61330   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61331   Dali::WheelEvent *arg2 = 0 ;
61332   SwigDirector_ViewImpl *darg = 0;
61333   bool result;
61334
61335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61336   arg2 = (Dali::WheelEvent *)jarg2;
61337   if (!arg2) {
61338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61339     return 0;
61340   }
61341   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61342   {
61343     try {
61344       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61345     } catch (std::out_of_range& e) {
61346       {
61347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61348       };
61349     } catch (std::exception& e) {
61350       {
61351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (...) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61356       };
61357     }
61358   }
61359   jresult = result;
61360   return jresult;
61361 }
61362
61363
61364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61365   unsigned int jresult ;
61366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61367   Dali::WheelEvent *arg2 = 0 ;
61368   SwigDirector_ViewImpl *darg = 0;
61369   bool result;
61370
61371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61372   arg2 = (Dali::WheelEvent *)jarg2;
61373   if (!arg2) {
61374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61375     return 0;
61376   }
61377   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61378   {
61379     try {
61380       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61381     } catch (std::out_of_range& e) {
61382       {
61383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61384       };
61385     } catch (std::exception& e) {
61386       {
61387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61392       };
61393     }
61394   }
61395   jresult = result;
61396   return jresult;
61397 }
61398
61399
61400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61402   Dali::Vector2 *arg2 = 0 ;
61403   Dali::RelayoutContainer *arg3 = 0 ;
61404   SwigDirector_ViewImpl *darg = 0;
61405
61406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61407   arg2 = (Dali::Vector2 *)jarg2;
61408   if (!arg2) {
61409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61410     return ;
61411   }
61412   arg3 = (Dali::RelayoutContainer *)jarg3;
61413   if (!arg3) {
61414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61415     return ;
61416   }
61417   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61418   {
61419     try {
61420       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61421     } catch (std::out_of_range& e) {
61422       {
61423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61424       };
61425     } catch (std::exception& e) {
61426       {
61427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61428       };
61429     } catch (...) {
61430       {
61431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61432       };
61433     }
61434   }
61435 }
61436
61437
61438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61440   Dali::Vector2 *arg2 = 0 ;
61441   Dali::RelayoutContainer *arg3 = 0 ;
61442   SwigDirector_ViewImpl *darg = 0;
61443
61444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61445   arg2 = (Dali::Vector2 *)jarg2;
61446   if (!arg2) {
61447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61448     return ;
61449   }
61450   arg3 = (Dali::RelayoutContainer *)jarg3;
61451   if (!arg3) {
61452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61453     return ;
61454   }
61455   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61456   {
61457     try {
61458       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61459     } catch (std::out_of_range& e) {
61460       {
61461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61462       };
61463     } catch (std::exception& e) {
61464       {
61465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (...) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61470       };
61471     }
61472   }
61473 }
61474
61475
61476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61478   Dali::ResizePolicy::Type arg2 ;
61479   Dali::Dimension::Type arg3 ;
61480   SwigDirector_ViewImpl *darg = 0;
61481
61482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61483   arg2 = (Dali::ResizePolicy::Type)jarg2;
61484   arg3 = (Dali::Dimension::Type)jarg3;
61485   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61486   {
61487     try {
61488       (darg)->OnSetResizePolicy(arg2,arg3);
61489     } catch (std::out_of_range& e) {
61490       {
61491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61492       };
61493     } catch (std::exception& e) {
61494       {
61495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61496       };
61497     } catch (...) {
61498       {
61499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61500       };
61501     }
61502   }
61503 }
61504
61505
61506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61508   Dali::ResizePolicy::Type arg2 ;
61509   Dali::Dimension::Type arg3 ;
61510   SwigDirector_ViewImpl *darg = 0;
61511
61512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61513   arg2 = (Dali::ResizePolicy::Type)jarg2;
61514   arg3 = (Dali::Dimension::Type)jarg3;
61515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61516   {
61517     try {
61518       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61519     } catch (std::out_of_range& e) {
61520       {
61521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61522       };
61523     } catch (std::exception& e) {
61524       {
61525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61526       };
61527     } catch (...) {
61528       {
61529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61530       };
61531     }
61532   }
61533 }
61534
61535
61536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61537   void * jresult ;
61538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61539   SwigDirector_ViewImpl *darg = 0;
61540   Dali::Vector3 result;
61541
61542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61543   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61544   {
61545     try {
61546       result = (darg)->GetNaturalSize();
61547     } catch (std::out_of_range& e) {
61548       {
61549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61550       };
61551     } catch (std::exception& e) {
61552       {
61553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61554       };
61555     } catch (...) {
61556       {
61557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61558       };
61559     }
61560   }
61561   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61562   return jresult;
61563 }
61564
61565
61566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61567   void * jresult ;
61568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61569   SwigDirector_ViewImpl *darg = 0;
61570   Dali::Vector3 result;
61571
61572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61573   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61574   {
61575     try {
61576       result = (darg)->GetNaturalSizeSwigPublic();
61577     } catch (std::out_of_range& e) {
61578       {
61579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61580       };
61581     } catch (std::exception& e) {
61582       {
61583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61584       };
61585     } catch (...) {
61586       {
61587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61588       };
61589     }
61590   }
61591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61592   return jresult;
61593 }
61594
61595
61596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61597   float jresult ;
61598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61599   Dali::Actor *arg2 = 0 ;
61600   Dali::Dimension::Type arg3 ;
61601   SwigDirector_ViewImpl *darg = 0;
61602   float result;
61603
61604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61605   arg2 = (Dali::Actor *)jarg2;
61606   if (!arg2) {
61607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61608     return 0;
61609   }
61610   arg3 = (Dali::Dimension::Type)jarg3;
61611   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61612   {
61613     try {
61614       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61615     } catch (std::out_of_range& e) {
61616       {
61617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61618       };
61619     } catch (std::exception& e) {
61620       {
61621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61622       };
61623     } catch (...) {
61624       {
61625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61626       };
61627     }
61628   }
61629   jresult = result;
61630   return jresult;
61631 }
61632
61633
61634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61635   float jresult ;
61636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61637   Dali::Actor *arg2 = 0 ;
61638   Dali::Dimension::Type arg3 ;
61639   SwigDirector_ViewImpl *darg = 0;
61640   float result;
61641
61642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61643   arg2 = (Dali::Actor *)jarg2;
61644   if (!arg2) {
61645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61646     return 0;
61647   }
61648   arg3 = (Dali::Dimension::Type)jarg3;
61649   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61650   {
61651     try {
61652       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61653     } catch (std::out_of_range& e) {
61654       {
61655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61656       };
61657     } catch (std::exception& e) {
61658       {
61659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61660       };
61661     } catch (...) {
61662       {
61663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61664       };
61665     }
61666   }
61667   jresult = result;
61668   return jresult;
61669 }
61670
61671
61672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61673   float jresult ;
61674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61675   float arg2 ;
61676   SwigDirector_ViewImpl *darg = 0;
61677   float result;
61678
61679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61680   arg2 = (float)jarg2;
61681   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61682   {
61683     try {
61684       result = (float)(darg)->GetHeightForWidth(arg2);
61685     } catch (std::out_of_range& e) {
61686       {
61687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61688       };
61689     } catch (std::exception& e) {
61690       {
61691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61692       };
61693     } catch (...) {
61694       {
61695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61696       };
61697     }
61698   }
61699   jresult = result;
61700   return jresult;
61701 }
61702
61703
61704 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61705   float jresult ;
61706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61707   float arg2 ;
61708   SwigDirector_ViewImpl *darg = 0;
61709   float result;
61710
61711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61712   arg2 = (float)jarg2;
61713   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61714   {
61715     try {
61716       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61717     } catch (std::out_of_range& e) {
61718       {
61719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61720       };
61721     } catch (std::exception& e) {
61722       {
61723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61724       };
61725     } catch (...) {
61726       {
61727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61728       };
61729     }
61730   }
61731   jresult = result;
61732   return jresult;
61733 }
61734
61735
61736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61737   float jresult ;
61738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61739   float arg2 ;
61740   SwigDirector_ViewImpl *darg = 0;
61741   float result;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   arg2 = (float)jarg2;
61745   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61746   {
61747     try {
61748       result = (float)(darg)->GetWidthForHeight(arg2);
61749     } catch (std::out_of_range& e) {
61750       {
61751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61752       };
61753     } catch (std::exception& e) {
61754       {
61755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61756       };
61757     } catch (...) {
61758       {
61759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61760       };
61761     }
61762   }
61763   jresult = result;
61764   return jresult;
61765 }
61766
61767
61768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61769   float jresult ;
61770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61771   float arg2 ;
61772   SwigDirector_ViewImpl *darg = 0;
61773   float result;
61774
61775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61776   arg2 = (float)jarg2;
61777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61778   {
61779     try {
61780       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61781     } catch (std::out_of_range& e) {
61782       {
61783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61784       };
61785     } catch (std::exception& e) {
61786       {
61787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61788       };
61789     } catch (...) {
61790       {
61791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61792       };
61793     }
61794   }
61795   jresult = result;
61796   return jresult;
61797 }
61798
61799
61800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61801   unsigned int jresult ;
61802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61803   Dali::Dimension::Type arg2 ;
61804   SwigDirector_ViewImpl *darg = 0;
61805   bool result;
61806
61807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61808   arg2 = (Dali::Dimension::Type)jarg2;
61809   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61810   {
61811     try {
61812       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61820       };
61821     } catch (...) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61824       };
61825     }
61826   }
61827   jresult = result;
61828   return jresult;
61829 }
61830
61831
61832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61833   unsigned int jresult ;
61834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61835   Dali::Dimension::Type arg2 ;
61836   SwigDirector_ViewImpl *darg = 0;
61837   bool result;
61838
61839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61840   arg2 = (Dali::Dimension::Type)jarg2;
61841   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61842   {
61843     try {
61844       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61845     } catch (std::out_of_range& e) {
61846       {
61847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61848       };
61849     } catch (std::exception& e) {
61850       {
61851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61852       };
61853     } catch (...) {
61854       {
61855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61856       };
61857     }
61858   }
61859   jresult = result;
61860   return jresult;
61861 }
61862
61863
61864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61865   unsigned int jresult ;
61866   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61867   SwigDirector_ViewImpl *darg = 0;
61868   bool result;
61869
61870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61871   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61872   {
61873     try {
61874       result = (bool)(darg)->RelayoutDependentOnChildren();
61875     } catch (std::out_of_range& e) {
61876       {
61877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61878       };
61879     } catch (std::exception& e) {
61880       {
61881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61882       };
61883     } catch (...) {
61884       {
61885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61886       };
61887     }
61888   }
61889   jresult = result;
61890   return jresult;
61891 }
61892
61893
61894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61895   unsigned int jresult ;
61896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61897   SwigDirector_ViewImpl *darg = 0;
61898   bool result;
61899
61900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61901   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61902   {
61903     try {
61904       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61905     } catch (std::out_of_range& e) {
61906       {
61907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61908       };
61909     } catch (std::exception& e) {
61910       {
61911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61912       };
61913     } catch (...) {
61914       {
61915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61916       };
61917     }
61918   }
61919   jresult = result;
61920   return jresult;
61921 }
61922
61923
61924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61926   Dali::Dimension::Type arg2 ;
61927   SwigDirector_ViewImpl *darg = 0;
61928
61929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61930   arg2 = (Dali::Dimension::Type)jarg2;
61931   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61932   {
61933     try {
61934       (darg)->OnCalculateRelayoutSize(arg2);
61935     } catch (std::out_of_range& e) {
61936       {
61937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61938       };
61939     } catch (std::exception& e) {
61940       {
61941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61942       };
61943     } catch (...) {
61944       {
61945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61946       };
61947     }
61948   }
61949 }
61950
61951
61952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61954   Dali::Dimension::Type arg2 ;
61955   SwigDirector_ViewImpl *darg = 0;
61956
61957   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61958   arg2 = (Dali::Dimension::Type)jarg2;
61959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61960   {
61961     try {
61962       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61963     } catch (std::out_of_range& e) {
61964       {
61965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61966       };
61967     } catch (std::exception& e) {
61968       {
61969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61970       };
61971     } catch (...) {
61972       {
61973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61974       };
61975     }
61976   }
61977 }
61978
61979
61980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61982   float arg2 ;
61983   Dali::Dimension::Type arg3 ;
61984   SwigDirector_ViewImpl *darg = 0;
61985
61986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61987   arg2 = (float)jarg2;
61988   arg3 = (Dali::Dimension::Type)jarg3;
61989   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61990   {
61991     try {
61992       (darg)->OnLayoutNegotiated(arg2,arg3);
61993     } catch (std::out_of_range& e) {
61994       {
61995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61996       };
61997     } catch (std::exception& e) {
61998       {
61999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62000       };
62001     } catch (...) {
62002       {
62003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62004       };
62005     }
62006   }
62007 }
62008
62009
62010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62012   float arg2 ;
62013   Dali::Dimension::Type arg3 ;
62014   SwigDirector_ViewImpl *darg = 0;
62015
62016   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62017   arg2 = (float)jarg2;
62018   arg3 = (Dali::Dimension::Type)jarg3;
62019   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62020   {
62021     try {
62022       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
62023     } catch (std::out_of_range& e) {
62024       {
62025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62026       };
62027     } catch (std::exception& e) {
62028       {
62029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62030       };
62031     } catch (...) {
62032       {
62033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62034       };
62035     }
62036   }
62037 }
62038
62039
62040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62041   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62042
62043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62044   {
62045     try {
62046       (arg1)->OnInitialize();
62047     } catch (std::out_of_range& e) {
62048       {
62049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62050       };
62051     } catch (std::exception& e) {
62052       {
62053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62054       };
62055     } catch (...) {
62056       {
62057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62058       };
62059     }
62060   }
62061 }
62062
62063
62064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62066
62067   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62068   {
62069     try {
62070       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62071     } catch (std::out_of_range& e) {
62072       {
62073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62074       };
62075     } catch (std::exception& e) {
62076       {
62077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62078       };
62079     } catch (...) {
62080       {
62081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62082       };
62083     }
62084   }
62085 }
62086
62087
62088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62090   Dali::Actor *arg2 = 0 ;
62091
62092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62093   arg2 = (Dali::Actor *)jarg2;
62094   if (!arg2) {
62095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62096     return ;
62097   }
62098   {
62099     try {
62100       (arg1)->OnControlChildAdd(*arg2);
62101     } catch (std::out_of_range& e) {
62102       {
62103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62104       };
62105     } catch (std::exception& e) {
62106       {
62107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62108       };
62109     } catch (...) {
62110       {
62111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62112       };
62113     }
62114   }
62115 }
62116
62117
62118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62120   Dali::Actor *arg2 = 0 ;
62121
62122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62123   arg2 = (Dali::Actor *)jarg2;
62124   if (!arg2) {
62125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62126     return ;
62127   }
62128   {
62129     try {
62130       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62131     } catch (std::out_of_range& e) {
62132       {
62133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62134       };
62135     } catch (std::exception& e) {
62136       {
62137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62138       };
62139     } catch (...) {
62140       {
62141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62142       };
62143     }
62144   }
62145 }
62146
62147
62148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62150   Dali::Actor *arg2 = 0 ;
62151
62152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62153   arg2 = (Dali::Actor *)jarg2;
62154   if (!arg2) {
62155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62156     return ;
62157   }
62158   {
62159     try {
62160       (arg1)->OnControlChildRemove(*arg2);
62161     } catch (std::out_of_range& e) {
62162       {
62163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62164       };
62165     } catch (std::exception& e) {
62166       {
62167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62168       };
62169     } catch (...) {
62170       {
62171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62172       };
62173     }
62174   }
62175 }
62176
62177
62178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62180   Dali::Actor *arg2 = 0 ;
62181
62182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62183   arg2 = (Dali::Actor *)jarg2;
62184   if (!arg2) {
62185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62186     return ;
62187   }
62188   {
62189     try {
62190       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62191     } catch (std::out_of_range& e) {
62192       {
62193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62194       };
62195     } catch (std::exception& e) {
62196       {
62197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62198       };
62199     } catch (...) {
62200       {
62201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62202       };
62203     }
62204   }
62205 }
62206
62207
62208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62210   Dali::Toolkit::StyleManager arg2 ;
62211   Dali::StyleChange::Type arg3 ;
62212   Dali::Toolkit::StyleManager *argp2 ;
62213
62214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62215   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62216   if (!argp2) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62218     return ;
62219   }
62220   arg2 = *argp2;
62221   arg3 = (Dali::StyleChange::Type)jarg3;
62222   {
62223     try {
62224       (arg1)->OnStyleChange(arg2,arg3);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62232       };
62233     } catch (...) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62236       };
62237     }
62238   }
62239 }
62240
62241
62242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62244   Dali::Toolkit::StyleManager arg2 ;
62245   Dali::StyleChange::Type arg3 ;
62246   Dali::Toolkit::StyleManager *argp2 ;
62247
62248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62249   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62250   if (!argp2) {
62251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62252     return ;
62253   }
62254   arg2 = *argp2;
62255   arg3 = (Dali::StyleChange::Type)jarg3;
62256   {
62257     try {
62258       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62259     } catch (std::out_of_range& e) {
62260       {
62261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62262       };
62263     } catch (std::exception& e) {
62264       {
62265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62266       };
62267     } catch (...) {
62268       {
62269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62270       };
62271     }
62272   }
62273 }
62274
62275
62276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62277   unsigned int jresult ;
62278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62279   bool result;
62280
62281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62282   {
62283     try {
62284       result = (bool)(arg1)->OnAccessibilityActivated();
62285     } catch (std::out_of_range& e) {
62286       {
62287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62288       };
62289     } catch (std::exception& e) {
62290       {
62291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62292       };
62293     } catch (...) {
62294       {
62295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62296       };
62297     }
62298   }
62299   jresult = result;
62300   return jresult;
62301 }
62302
62303
62304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62305   unsigned int jresult ;
62306   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62307   bool result;
62308
62309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62310   {
62311     try {
62312       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62313     } catch (std::out_of_range& e) {
62314       {
62315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62316       };
62317     } catch (std::exception& e) {
62318       {
62319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62320       };
62321     } catch (...) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62324       };
62325     }
62326   }
62327   jresult = result;
62328   return jresult;
62329 }
62330
62331
62332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62333   unsigned int jresult ;
62334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62335   Dali::PanGesture arg2 ;
62336   Dali::PanGesture *argp2 ;
62337   bool result;
62338
62339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62340   argp2 = (Dali::PanGesture *)jarg2;
62341   if (!argp2) {
62342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62343     return 0;
62344   }
62345   arg2 = *argp2;
62346   {
62347     try {
62348       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62349     } catch (std::out_of_range& e) {
62350       {
62351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62352       };
62353     } catch (std::exception& e) {
62354       {
62355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62356       };
62357     } catch (...) {
62358       {
62359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62360       };
62361     }
62362   }
62363   jresult = result;
62364   return jresult;
62365 }
62366
62367
62368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62369   unsigned int jresult ;
62370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62371   Dali::PanGesture arg2 ;
62372   Dali::PanGesture *argp2 ;
62373   bool result;
62374
62375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62376   argp2 = (Dali::PanGesture *)jarg2;
62377   if (!argp2) {
62378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62379     return 0;
62380   }
62381   arg2 = *argp2;
62382   {
62383     try {
62384       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62385     } catch (std::out_of_range& e) {
62386       {
62387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62388       };
62389     } catch (std::exception& e) {
62390       {
62391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62392       };
62393     } catch (...) {
62394       {
62395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62396       };
62397     }
62398   }
62399   jresult = result;
62400   return jresult;
62401 }
62402
62403
62404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62405   unsigned int jresult ;
62406   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62407   Dali::TouchEvent *arg2 = 0 ;
62408   bool result;
62409
62410   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62411   arg2 = (Dali::TouchEvent *)jarg2;
62412   if (!arg2) {
62413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62414     return 0;
62415   }
62416   {
62417     try {
62418       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62419     } catch (std::out_of_range& e) {
62420       {
62421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62422       };
62423     } catch (std::exception& e) {
62424       {
62425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62426       };
62427     } catch (...) {
62428       {
62429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62430       };
62431     }
62432   }
62433   jresult = result;
62434   return jresult;
62435 }
62436
62437
62438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62439   unsigned int jresult ;
62440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62441   Dali::TouchEvent *arg2 = 0 ;
62442   bool result;
62443
62444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62445   arg2 = (Dali::TouchEvent *)jarg2;
62446   if (!arg2) {
62447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62448     return 0;
62449   }
62450   {
62451     try {
62452       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62453     } catch (std::out_of_range& e) {
62454       {
62455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62456       };
62457     } catch (std::exception& e) {
62458       {
62459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62460       };
62461     } catch (...) {
62462       {
62463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62464       };
62465     }
62466   }
62467   jresult = result;
62468   return jresult;
62469 }
62470
62471
62472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62473   unsigned int jresult ;
62474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62475   bool arg2 ;
62476   bool result;
62477
62478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62479   arg2 = jarg2 ? true : false;
62480   {
62481     try {
62482       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62483     } catch (std::out_of_range& e) {
62484       {
62485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62486       };
62487     } catch (std::exception& e) {
62488       {
62489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62490       };
62491     } catch (...) {
62492       {
62493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62494       };
62495     }
62496   }
62497   jresult = result;
62498   return jresult;
62499 }
62500
62501
62502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62503   unsigned int jresult ;
62504   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62505   bool arg2 ;
62506   bool result;
62507
62508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62509   arg2 = jarg2 ? true : false;
62510   {
62511     try {
62512       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62513     } catch (std::out_of_range& e) {
62514       {
62515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62516       };
62517     } catch (std::exception& e) {
62518       {
62519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62520       };
62521     } catch (...) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62524       };
62525     }
62526   }
62527   jresult = result;
62528   return jresult;
62529 }
62530
62531
62532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62533   unsigned int jresult ;
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   bool result;
62536
62537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62538   {
62539     try {
62540       result = (bool)(arg1)->OnAccessibilityZoom();
62541     } catch (std::out_of_range& e) {
62542       {
62543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62544       };
62545     } catch (std::exception& e) {
62546       {
62547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62548       };
62549     } catch (...) {
62550       {
62551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62552       };
62553     }
62554   }
62555   jresult = result;
62556   return jresult;
62557 }
62558
62559
62560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62561   unsigned int jresult ;
62562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62563   bool result;
62564
62565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62566   {
62567     try {
62568       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (...) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62580       };
62581     }
62582   }
62583   jresult = result;
62584   return jresult;
62585 }
62586
62587
62588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62590
62591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62592   {
62593     try {
62594       (arg1)->OnKeyInputFocusGained();
62595     } catch (std::out_of_range& e) {
62596       {
62597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62598       };
62599     } catch (std::exception& e) {
62600       {
62601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62602       };
62603     } catch (...) {
62604       {
62605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62606       };
62607     }
62608   }
62609 }
62610
62611
62612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62614
62615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62616   {
62617     try {
62618       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62619     } catch (std::out_of_range& e) {
62620       {
62621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62622       };
62623     } catch (std::exception& e) {
62624       {
62625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62630       };
62631     }
62632   }
62633 }
62634
62635
62636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62638
62639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62640   {
62641     try {
62642       (arg1)->OnKeyInputFocusLost();
62643     } catch (std::out_of_range& e) {
62644       {
62645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62646       };
62647     } catch (std::exception& e) {
62648       {
62649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62650       };
62651     } catch (...) {
62652       {
62653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62654       };
62655     }
62656   }
62657 }
62658
62659
62660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62662
62663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62664   {
62665     try {
62666       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62667     } catch (std::out_of_range& e) {
62668       {
62669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62670       };
62671     } catch (std::exception& e) {
62672       {
62673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62674       };
62675     } catch (...) {
62676       {
62677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62678       };
62679     }
62680   }
62681 }
62682
62683
62684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62685   void * jresult ;
62686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62687   Dali::Actor arg2 ;
62688   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62689   bool arg4 ;
62690   Dali::Actor *argp2 ;
62691   Dali::Actor result;
62692
62693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62694   argp2 = (Dali::Actor *)jarg2;
62695   if (!argp2) {
62696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62697     return 0;
62698   }
62699   arg2 = *argp2;
62700   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62701   arg4 = jarg4 ? true : false;
62702   {
62703     try {
62704       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62705     } catch (std::out_of_range& e) {
62706       {
62707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62708       };
62709     } catch (std::exception& e) {
62710       {
62711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62712       };
62713     } catch (...) {
62714       {
62715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62716       };
62717     }
62718   }
62719   jresult = new Dali::Actor((const Dali::Actor &)result);
62720   return jresult;
62721 }
62722
62723
62724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62725   void * jresult ;
62726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62727   Dali::Actor arg2 ;
62728   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62729   bool arg4 ;
62730   Dali::Actor *argp2 ;
62731   Dali::Actor result;
62732
62733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62734   argp2 = (Dali::Actor *)jarg2;
62735   if (!argp2) {
62736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62737     return 0;
62738   }
62739   arg2 = *argp2;
62740   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62741   arg4 = jarg4 ? true : false;
62742   {
62743     try {
62744       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62745     } catch (std::out_of_range& e) {
62746       {
62747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62748       };
62749     } catch (std::exception& e) {
62750       {
62751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62752       };
62753     } catch (...) {
62754       {
62755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62756       };
62757     }
62758   }
62759   jresult = new Dali::Actor((const Dali::Actor &)result);
62760   return jresult;
62761 }
62762
62763
62764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62766   Dali::Actor arg2 ;
62767   Dali::Actor *argp2 ;
62768
62769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62770   argp2 = (Dali::Actor *)jarg2;
62771   if (!argp2) {
62772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62773     return ;
62774   }
62775   arg2 = *argp2;
62776   {
62777     try {
62778       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62779     } catch (std::out_of_range& e) {
62780       {
62781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62782       };
62783     } catch (std::exception& e) {
62784       {
62785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62786       };
62787     } catch (...) {
62788       {
62789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62790       };
62791     }
62792   }
62793 }
62794
62795
62796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62798   Dali::Actor arg2 ;
62799   Dali::Actor *argp2 ;
62800
62801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62802   argp2 = (Dali::Actor *)jarg2;
62803   if (!argp2) {
62804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62805     return ;
62806   }
62807   arg2 = *argp2;
62808   {
62809     try {
62810       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62811     } catch (std::out_of_range& e) {
62812       {
62813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62814       };
62815     } catch (std::exception& e) {
62816       {
62817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62818       };
62819     } catch (...) {
62820       {
62821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62822       };
62823     }
62824   }
62825 }
62826
62827
62828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62829   unsigned int jresult ;
62830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62831   bool result;
62832
62833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62834   {
62835     try {
62836       result = (bool)(arg1)->OnKeyboardEnter();
62837     } catch (std::out_of_range& e) {
62838       {
62839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62840       };
62841     } catch (std::exception& e) {
62842       {
62843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62844       };
62845     } catch (...) {
62846       {
62847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62848       };
62849     }
62850   }
62851   jresult = result;
62852   return jresult;
62853 }
62854
62855
62856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62857   unsigned int jresult ;
62858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62859   bool result;
62860
62861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62862   {
62863     try {
62864       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62865     } catch (std::out_of_range& e) {
62866       {
62867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62868       };
62869     } catch (std::exception& e) {
62870       {
62871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62872       };
62873     } catch (...) {
62874       {
62875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62876       };
62877     }
62878   }
62879   jresult = result;
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62886   Dali::PinchGesture *arg2 = 0 ;
62887
62888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62889   arg2 = (Dali::PinchGesture *)jarg2;
62890   if (!arg2) {
62891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62892     return ;
62893   }
62894   {
62895     try {
62896       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62897     } catch (std::out_of_range& e) {
62898       {
62899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62900       };
62901     } catch (std::exception& e) {
62902       {
62903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62904       };
62905     } catch (...) {
62906       {
62907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62908       };
62909     }
62910   }
62911 }
62912
62913
62914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62916   Dali::PinchGesture *arg2 = 0 ;
62917
62918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62919   arg2 = (Dali::PinchGesture *)jarg2;
62920   if (!arg2) {
62921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62922     return ;
62923   }
62924   {
62925     try {
62926       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62927     } catch (std::out_of_range& e) {
62928       {
62929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62930       };
62931     } catch (std::exception& e) {
62932       {
62933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62934       };
62935     } catch (...) {
62936       {
62937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62938       };
62939     }
62940   }
62941 }
62942
62943
62944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62946   Dali::PanGesture *arg2 = 0 ;
62947
62948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62949   arg2 = (Dali::PanGesture *)jarg2;
62950   if (!arg2) {
62951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62952     return ;
62953   }
62954   {
62955     try {
62956       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62957     } catch (std::out_of_range& e) {
62958       {
62959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62960       };
62961     } catch (std::exception& e) {
62962       {
62963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62964       };
62965     } catch (...) {
62966       {
62967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62968       };
62969     }
62970   }
62971 }
62972
62973
62974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62976   Dali::PanGesture *arg2 = 0 ;
62977
62978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62979   arg2 = (Dali::PanGesture *)jarg2;
62980   if (!arg2) {
62981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62982     return ;
62983   }
62984   {
62985     try {
62986       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62987     } catch (std::out_of_range& e) {
62988       {
62989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62990       };
62991     } catch (std::exception& e) {
62992       {
62993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62994       };
62995     } catch (...) {
62996       {
62997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62998       };
62999     }
63000   }
63001 }
63002
63003
63004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63006   Dali::TapGesture *arg2 = 0 ;
63007
63008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63009   arg2 = (Dali::TapGesture *)jarg2;
63010   if (!arg2) {
63011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63012     return ;
63013   }
63014   {
63015     try {
63016       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63017     } catch (std::out_of_range& e) {
63018       {
63019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63020       };
63021     } catch (std::exception& e) {
63022       {
63023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63024       };
63025     } catch (...) {
63026       {
63027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63028       };
63029     }
63030   }
63031 }
63032
63033
63034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63036   Dali::TapGesture *arg2 = 0 ;
63037
63038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63039   arg2 = (Dali::TapGesture *)jarg2;
63040   if (!arg2) {
63041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63042     return ;
63043   }
63044   {
63045     try {
63046       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63047     } catch (std::out_of_range& e) {
63048       {
63049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63050       };
63051     } catch (std::exception& e) {
63052       {
63053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63054       };
63055     } catch (...) {
63056       {
63057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63058       };
63059     }
63060   }
63061 }
63062
63063
63064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63066   Dali::LongPressGesture *arg2 = 0 ;
63067
63068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63069   arg2 = (Dali::LongPressGesture *)jarg2;
63070   if (!arg2) {
63071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63072     return ;
63073   }
63074   {
63075     try {
63076       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63084       };
63085     } catch (...) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63088       };
63089     }
63090   }
63091 }
63092
63093
63094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63096   Dali::LongPressGesture *arg2 = 0 ;
63097
63098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63099   arg2 = (Dali::LongPressGesture *)jarg2;
63100   if (!arg2) {
63101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63102     return ;
63103   }
63104   {
63105     try {
63106       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63107     } catch (std::out_of_range& e) {
63108       {
63109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63110       };
63111     } catch (std::exception& e) {
63112       {
63113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63114       };
63115     } catch (...) {
63116       {
63117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63118       };
63119     }
63120   }
63121 }
63122
63123
63124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63125   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63126   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63127   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63128
63129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63130   arg2 = (Dali::SlotObserver *)jarg2;
63131   arg3 = (Dali::CallbackBase *)jarg3;
63132   {
63133     try {
63134       (arg1)->SignalConnected(arg2,arg3);
63135     } catch (std::out_of_range& e) {
63136       {
63137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63138       };
63139     } catch (std::exception& e) {
63140       {
63141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63142       };
63143     } catch (...) {
63144       {
63145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63146       };
63147     }
63148   }
63149 }
63150
63151
63152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63154   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63155   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63156
63157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63158   arg2 = (Dali::SlotObserver *)jarg2;
63159   arg3 = (Dali::CallbackBase *)jarg3;
63160   {
63161     try {
63162       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63163     } catch (std::out_of_range& e) {
63164       {
63165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63166       };
63167     } catch (std::exception& e) {
63168       {
63169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63170       };
63171     } catch (...) {
63172       {
63173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63174       };
63175     }
63176   }
63177 }
63178
63179
63180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63182   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63183   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63184
63185   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63186   arg2 = (Dali::SlotObserver *)jarg2;
63187   arg3 = (Dali::CallbackBase *)jarg3;
63188   {
63189     try {
63190       (arg1)->SignalDisconnected(arg2,arg3);
63191     } catch (std::out_of_range& e) {
63192       {
63193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63194       };
63195     } catch (std::exception& e) {
63196       {
63197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63202       };
63203     }
63204   }
63205 }
63206
63207
63208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63210   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63211   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63212
63213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63214   arg2 = (Dali::SlotObserver *)jarg2;
63215   arg3 = (Dali::CallbackBase *)jarg3;
63216   {
63217     try {
63218       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63219     } catch (std::out_of_range& e) {
63220       {
63221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63222       };
63223     } catch (std::exception& e) {
63224       {
63225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63226       };
63227     } catch (...) {
63228       {
63229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63230       };
63231     }
63232   }
63233 }
63234
63235
63236 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) {
63237   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63238   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63239   if (director) {
63240     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);
63241   }
63242 }
63243
63244
63245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63246   void * jresult ;
63247   Dali::Toolkit::Control *arg1 = 0 ;
63248   Dali::Toolkit::Internal::Control *result = 0 ;
63249
63250   arg1 = (Dali::Toolkit::Control *)jarg1;
63251   if (!arg1) {
63252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63253     return 0;
63254   }
63255   {
63256     try {
63257       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63258     } catch (std::out_of_range& e) {
63259       {
63260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63261       };
63262     } catch (std::exception& e) {
63263       {
63264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63265       };
63266     } catch (...) {
63267       {
63268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63269       };
63270     }
63271   }
63272   jresult = (void *)result;
63273   return jresult;
63274 }
63275
63276
63277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63278   int jresult ;
63279   int result;
63280
63281   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63282   jresult = (int)result;
63283   return jresult;
63284 }
63285
63286
63287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63288   int jresult ;
63289   int result;
63290
63291   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63292   jresult = (int)result;
63293   return jresult;
63294 }
63295
63296
63297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63298   int jresult ;
63299   int result;
63300
63301   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63302   jresult = (int)result;
63303   return jresult;
63304 }
63305
63306
63307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63308   int jresult ;
63309   int result;
63310
63311   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63312   jresult = (int)result;
63313   return jresult;
63314 }
63315
63316
63317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63318   int jresult ;
63319   int result;
63320
63321   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63322   jresult = (int)result;
63323   return jresult;
63324 }
63325
63326
63327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63328   void * jresult ;
63329   Dali::Toolkit::Control::Property *result = 0 ;
63330
63331   {
63332     try {
63333       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63334     } catch (std::out_of_range& e) {
63335       {
63336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63337       };
63338     } catch (std::exception& e) {
63339       {
63340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63341       };
63342     } catch (...) {
63343       {
63344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63345       };
63346     }
63347   }
63348   jresult = (void *)result;
63349   return jresult;
63350 }
63351
63352
63353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63354   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63355
63356   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63357   {
63358     try {
63359       delete arg1;
63360     } catch (std::out_of_range& e) {
63361       {
63362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63363       };
63364     } catch (std::exception& e) {
63365       {
63366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63367       };
63368     } catch (...) {
63369       {
63370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63371       };
63372     }
63373   }
63374 }
63375
63376
63377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63378   void * jresult ;
63379   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63380
63381   {
63382     try {
63383       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63384     } catch (std::out_of_range& e) {
63385       {
63386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63387       };
63388     } catch (std::exception& e) {
63389       {
63390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63391       };
63392     } catch (...) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63395       };
63396     }
63397   }
63398   jresult = (void *)result;
63399   return jresult;
63400 }
63401
63402
63403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63404   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63405
63406   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63407   {
63408     try {
63409       delete arg1;
63410     } catch (std::out_of_range& e) {
63411       {
63412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63413       };
63414     } catch (std::exception& e) {
63415       {
63416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63417       };
63418     } catch (...) {
63419       {
63420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63421       };
63422     }
63423   }
63424 }
63425
63426
63427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63428   void * jresult ;
63429   Dali::Toolkit::Control result;
63430
63431   {
63432     try {
63433       result = Dali::Toolkit::Control::New();
63434     } catch (std::out_of_range& e) {
63435       {
63436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (std::exception& e) {
63439       {
63440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (...) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63445       };
63446     }
63447   }
63448   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63449   return jresult;
63450 }
63451
63452
63453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63454   void * jresult ;
63455   Dali::Toolkit::Control *result = 0 ;
63456
63457   {
63458     try {
63459       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63460     } catch (std::out_of_range& e) {
63461       {
63462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63463       };
63464     } catch (std::exception& e) {
63465       {
63466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63467       };
63468     } catch (...) {
63469       {
63470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63471       };
63472     }
63473   }
63474   jresult = (void *)result;
63475   return jresult;
63476 }
63477
63478
63479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63480   void * jresult ;
63481   Dali::Toolkit::Control *arg1 = 0 ;
63482   Dali::Toolkit::Control *result = 0 ;
63483
63484   arg1 = (Dali::Toolkit::Control *)jarg1;
63485   if (!arg1) {
63486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63487     return 0;
63488   }
63489   {
63490     try {
63491       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63492     } catch (std::out_of_range& e) {
63493       {
63494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63495       };
63496     } catch (std::exception& e) {
63497       {
63498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63499       };
63500     } catch (...) {
63501       {
63502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63503       };
63504     }
63505   }
63506   jresult = (void *)result;
63507   return jresult;
63508 }
63509
63510
63511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63512   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63513
63514   arg1 = (Dali::Toolkit::Control *)jarg1;
63515   {
63516     try {
63517       delete arg1;
63518     } catch (std::out_of_range& e) {
63519       {
63520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63521       };
63522     } catch (std::exception& e) {
63523       {
63524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63525       };
63526     } catch (...) {
63527       {
63528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63529       };
63530     }
63531   }
63532 }
63533
63534
63535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63536   void * jresult ;
63537   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63538   Dali::Toolkit::Control *arg2 = 0 ;
63539   Dali::Toolkit::Control *result = 0 ;
63540
63541   arg1 = (Dali::Toolkit::Control *)jarg1;
63542   arg2 = (Dali::Toolkit::Control *)jarg2;
63543   if (!arg2) {
63544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63545     return 0;
63546   }
63547   {
63548     try {
63549       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63550     } catch (std::out_of_range& e) {
63551       {
63552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63553       };
63554     } catch (std::exception& e) {
63555       {
63556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63557       };
63558     } catch (...) {
63559       {
63560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63561       };
63562     }
63563   }
63564   jresult = (void *)result;
63565   return jresult;
63566 }
63567
63568
63569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63570   void * jresult ;
63571   Dali::BaseHandle arg1 ;
63572   Dali::BaseHandle *argp1 ;
63573   Dali::Toolkit::Control result;
63574
63575   argp1 = (Dali::BaseHandle *)jarg1;
63576   if (!argp1) {
63577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63578     return 0;
63579   }
63580   arg1 = *argp1;
63581   {
63582     try {
63583       result = Dali::Toolkit::Control::DownCast(arg1);
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63591       };
63592     } catch (...) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63595       };
63596     }
63597   }
63598   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63599   return jresult;
63600 }
63601
63602
63603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63604   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63605
63606   arg1 = (Dali::Toolkit::Control *)jarg1;
63607   {
63608     try {
63609       (arg1)->SetKeyInputFocus();
63610     } catch (std::out_of_range& e) {
63611       {
63612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63613       };
63614     } catch (std::exception& e) {
63615       {
63616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63617       };
63618     } catch (...) {
63619       {
63620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63621       };
63622     }
63623   }
63624 }
63625
63626
63627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63628   unsigned int jresult ;
63629   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63630   bool result;
63631
63632   arg1 = (Dali::Toolkit::Control *)jarg1;
63633   {
63634     try {
63635       result = (bool)(arg1)->HasKeyInputFocus();
63636     } catch (std::out_of_range& e) {
63637       {
63638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63639       };
63640     } catch (std::exception& e) {
63641       {
63642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63643       };
63644     } catch (...) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63647       };
63648     }
63649   }
63650   jresult = result;
63651   return jresult;
63652 }
63653
63654
63655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63656   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63657
63658   arg1 = (Dali::Toolkit::Control *)jarg1;
63659   {
63660     try {
63661       (arg1)->ClearKeyInputFocus();
63662     } catch (std::out_of_range& e) {
63663       {
63664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63665       };
63666     } catch (std::exception& e) {
63667       {
63668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63669       };
63670     } catch (...) {
63671       {
63672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63673       };
63674     }
63675   }
63676 }
63677
63678
63679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63680   void * jresult ;
63681   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63682   Dali::PinchGestureDetector result;
63683
63684   arg1 = (Dali::Toolkit::Control *)jarg1;
63685   {
63686     try {
63687       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63688     } catch (std::out_of_range& e) {
63689       {
63690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63691       };
63692     } catch (std::exception& e) {
63693       {
63694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63695       };
63696     } catch (...) {
63697       {
63698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63699       };
63700     }
63701   }
63702   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63703   return jresult;
63704 }
63705
63706
63707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63708   void * jresult ;
63709   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63710   Dali::PanGestureDetector result;
63711
63712   arg1 = (Dali::Toolkit::Control *)jarg1;
63713   {
63714     try {
63715       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63716     } catch (std::out_of_range& e) {
63717       {
63718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63719       };
63720     } catch (std::exception& e) {
63721       {
63722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63723       };
63724     } catch (...) {
63725       {
63726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63727       };
63728     }
63729   }
63730   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63731   return jresult;
63732 }
63733
63734
63735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63736   void * jresult ;
63737   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63738   Dali::TapGestureDetector result;
63739
63740   arg1 = (Dali::Toolkit::Control *)jarg1;
63741   {
63742     try {
63743       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63744     } catch (std::out_of_range& e) {
63745       {
63746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63747       };
63748     } catch (std::exception& e) {
63749       {
63750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63751       };
63752     } catch (...) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63755       };
63756     }
63757   }
63758   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63759   return jresult;
63760 }
63761
63762
63763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63764   void * jresult ;
63765   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63766   Dali::LongPressGestureDetector result;
63767
63768   arg1 = (Dali::Toolkit::Control *)jarg1;
63769   {
63770     try {
63771       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63772     } catch (std::out_of_range& e) {
63773       {
63774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63775       };
63776     } catch (std::exception& e) {
63777       {
63778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63779       };
63780     } catch (...) {
63781       {
63782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63783       };
63784     }
63785   }
63786   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63787   return jresult;
63788 }
63789
63790
63791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63792   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63793   std::string *arg2 = 0 ;
63794
63795   arg1 = (Dali::Toolkit::Control *)jarg1;
63796   if (!jarg2) {
63797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63798     return ;
63799   }
63800   std::string arg2_str(jarg2);
63801   arg2 = &arg2_str;
63802   {
63803     try {
63804       (arg1)->SetStyleName((std::string const &)*arg2);
63805     } catch (std::out_of_range& e) {
63806       {
63807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63808       };
63809     } catch (std::exception& e) {
63810       {
63811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63812       };
63813     } catch (...) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63816       };
63817     }
63818   }
63819
63820   //argout typemap for const std::string&
63821
63822 }
63823
63824
63825 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63826   char * jresult ;
63827   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63828   std::string *result = 0 ;
63829
63830   arg1 = (Dali::Toolkit::Control *)jarg1;
63831   {
63832     try {
63833       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (...) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63845       };
63846     }
63847   }
63848   jresult = SWIG_csharp_string_callback(result->c_str());
63849   return jresult;
63850 }
63851
63852
63853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63854   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63855   Dali::Vector4 *arg2 = 0 ;
63856
63857   arg1 = (Dali::Toolkit::Control *)jarg1;
63858   arg2 = (Dali::Vector4 *)jarg2;
63859   if (!arg2) {
63860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63861     return ;
63862   }
63863   {
63864     try {
63865       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63866     } catch (std::out_of_range& e) {
63867       {
63868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63869       };
63870     } catch (std::exception& e) {
63871       {
63872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63873       };
63874     } catch (...) {
63875       {
63876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63877       };
63878     }
63879   }
63880 }
63881
63882
63883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63884   void * jresult ;
63885   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63886   Dali::Vector4 result;
63887
63888   arg1 = (Dali::Toolkit::Control *)jarg1;
63889   {
63890     try {
63891       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
63892     } catch (std::out_of_range& e) {
63893       {
63894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63895       };
63896     } catch (std::exception& e) {
63897       {
63898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63899       };
63900     } catch (...) {
63901       {
63902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63903       };
63904     }
63905   }
63906   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63907   return jresult;
63908 }
63909
63910
63911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63912   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63913   Dali::Image arg2 ;
63914   Dali::Image *argp2 ;
63915
63916   arg1 = (Dali::Toolkit::Control *)jarg1;
63917   argp2 = (Dali::Image *)jarg2;
63918   if (!argp2) {
63919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63920     return ;
63921   }
63922   arg2 = *argp2;
63923   {
63924     try {
63925       (arg1)->SetBackgroundImage(arg2);
63926     } catch (std::out_of_range& e) {
63927       {
63928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63929       };
63930     } catch (std::exception& e) {
63931       {
63932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63933       };
63934     } catch (...) {
63935       {
63936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63937       };
63938     }
63939   }
63940 }
63941
63942
63943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63944   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63945
63946   arg1 = (Dali::Toolkit::Control *)jarg1;
63947   {
63948     try {
63949       (arg1)->ClearBackground();
63950     } catch (std::out_of_range& e) {
63951       {
63952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63953       };
63954     } catch (std::exception& e) {
63955       {
63956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63957       };
63958     } catch (...) {
63959       {
63960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63961       };
63962     }
63963   }
63964 }
63965
63966
63967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63968   void * jresult ;
63969   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63970   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63971
63972   arg1 = (Dali::Toolkit::Control *)jarg1;
63973   {
63974     try {
63975       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63987       };
63988     }
63989   }
63990   jresult = (void *)result;
63991   return jresult;
63992 }
63993
63994
63995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63996   void * jresult ;
63997   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63998   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63999
64000   arg1 = (Dali::Toolkit::Control *)jarg1;
64001   {
64002     try {
64003       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64004     } catch (std::out_of_range& e) {
64005       {
64006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64007       };
64008     } catch (std::exception& e) {
64009       {
64010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64011       };
64012     } catch (...) {
64013       {
64014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64015       };
64016     }
64017   }
64018   jresult = (void *)result;
64019   return jresult;
64020 }
64021
64022
64023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64024   void * jresult ;
64025   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64026   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64027
64028   arg1 = (Dali::Toolkit::Control *)jarg1;
64029   {
64030     try {
64031       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64032     } catch (std::out_of_range& e) {
64033       {
64034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64035       };
64036     } catch (std::exception& e) {
64037       {
64038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64039       };
64040     } catch (...) {
64041       {
64042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64043       };
64044     }
64045   }
64046   jresult = (void *)result;
64047   return jresult;
64048 }
64049
64050
64051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64052   void * jresult ;
64053   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64054   Dali::Toolkit::Control *result = 0 ;
64055
64056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64057   if (!arg1) {
64058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64059     return 0;
64060   }
64061   {
64062     try {
64063       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64064     } catch (std::out_of_range& e) {
64065       {
64066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64067       };
64068     } catch (std::exception& e) {
64069       {
64070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64071       };
64072     } catch (...) {
64073       {
64074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64075       };
64076     }
64077   }
64078   jresult = (void *)result;
64079   return jresult;
64080 }
64081
64082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64083   void * jresult ;
64084   Dali::Toolkit::Control *arg1 = 0 ;
64085   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
64086
64087   arg1 = (Dali::Toolkit::Control *)jarg1;
64088   if (!arg1) {
64089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64090     return 0;
64091   }
64092   {
64093     try {
64094       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
64095     } catch (std::out_of_range& e) {
64096       {
64097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64098       };
64099     } catch (std::exception& e) {
64100       {
64101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64102       };
64103     } catch (...) {
64104       {
64105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64106       };
64107     }
64108   }
64109   jresult = (void *)result;
64110   return jresult;
64111 }
64112
64113
64114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64115   unsigned int jresult ;
64116   Dali::Toolkit::Control *arg1 = 0 ;
64117   bool result;
64118
64119   arg1 = (Dali::Toolkit::Control *)jarg1;
64120   if (!arg1) {
64121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64122     return 0;
64123   }
64124   {
64125     try {
64126       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
64127     } catch (std::out_of_range& e) {
64128       {
64129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (std::exception& e) {
64132       {
64133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141   jresult = result;
64142   return jresult;
64143 }
64144
64145
64146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64147   void * jresult ;
64148   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64149
64150   {
64151     try {
64152       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64153     } catch (std::out_of_range& e) {
64154       {
64155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64156       };
64157     } catch (std::exception& e) {
64158       {
64159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64160       };
64161     } catch (...) {
64162       {
64163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64164       };
64165     }
64166   }
64167   jresult = (void *)result;
64168   return jresult;
64169 }
64170
64171
64172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64173   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64174
64175   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64176   {
64177     try {
64178       delete arg1;
64179     } catch (std::out_of_range& e) {
64180       {
64181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64182       };
64183     } catch (std::exception& e) {
64184       {
64185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (...) {
64188       {
64189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64190       };
64191     }
64192   }
64193 }
64194
64195
64196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64197   void * jresult ;
64198   Dali::Toolkit::KeyInputFocusManager result;
64199
64200   {
64201     try {
64202       result = Dali::Toolkit::KeyInputFocusManager::Get();
64203     } catch (std::out_of_range& e) {
64204       {
64205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64206       };
64207     } catch (std::exception& e) {
64208       {
64209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64210       };
64211     } catch (...) {
64212       {
64213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64214       };
64215     }
64216   }
64217   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64218   return jresult;
64219 }
64220
64221
64222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64223   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64224   Dali::Toolkit::Control arg2 ;
64225   Dali::Toolkit::Control *argp2 ;
64226
64227   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64228   argp2 = (Dali::Toolkit::Control *)jarg2;
64229   if (!argp2) {
64230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64231     return ;
64232   }
64233   arg2 = *argp2;
64234   {
64235     try {
64236       (arg1)->SetFocus(arg2);
64237     } catch (std::out_of_range& e) {
64238       {
64239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64240       };
64241     } catch (std::exception& e) {
64242       {
64243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64244       };
64245     } catch (...) {
64246       {
64247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64248       };
64249     }
64250   }
64251 }
64252
64253
64254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64255   void * jresult ;
64256   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64257   Dali::Toolkit::Control result;
64258
64259   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64260   {
64261     try {
64262       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64263     } catch (std::out_of_range& e) {
64264       {
64265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64266       };
64267     } catch (std::exception& e) {
64268       {
64269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64270       };
64271     } catch (...) {
64272       {
64273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64274       };
64275     }
64276   }
64277   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64278   return jresult;
64279 }
64280
64281
64282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64283   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64284   Dali::Toolkit::Control arg2 ;
64285   Dali::Toolkit::Control *argp2 ;
64286
64287   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64288   argp2 = (Dali::Toolkit::Control *)jarg2;
64289   if (!argp2) {
64290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64291     return ;
64292   }
64293   arg2 = *argp2;
64294   {
64295     try {
64296       (arg1)->RemoveFocus(arg2);
64297     } catch (std::out_of_range& e) {
64298       {
64299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64300       };
64301     } catch (std::exception& e) {
64302       {
64303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64304       };
64305     } catch (...) {
64306       {
64307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64308       };
64309     }
64310   }
64311 }
64312
64313
64314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64315   void * jresult ;
64316   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64317   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64318
64319   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64320   {
64321     try {
64322       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64323     } catch (std::out_of_range& e) {
64324       {
64325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64326       };
64327     } catch (std::exception& e) {
64328       {
64329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64330       };
64331     } catch (...) {
64332       {
64333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64334       };
64335     }
64336   }
64337   jresult = (void *)result;
64338   return jresult;
64339 }
64340
64341
64342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64343   void * jresult ;
64344   Dali::Toolkit::Alignment::Padding *result = 0 ;
64345
64346   {
64347     try {
64348       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64349     } catch (std::out_of_range& e) {
64350       {
64351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64352       };
64353     } catch (std::exception& e) {
64354       {
64355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64356       };
64357     } catch (...) {
64358       {
64359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64360       };
64361     }
64362   }
64363   jresult = (void *)result;
64364   return jresult;
64365 }
64366
64367
64368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64369   void * jresult ;
64370   float arg1 ;
64371   float arg2 ;
64372   float arg3 ;
64373   float arg4 ;
64374   Dali::Toolkit::Alignment::Padding *result = 0 ;
64375
64376   arg1 = (float)jarg1;
64377   arg2 = (float)jarg2;
64378   arg3 = (float)jarg3;
64379   arg4 = (float)jarg4;
64380   {
64381     try {
64382       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64383     } catch (std::out_of_range& e) {
64384       {
64385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64386       };
64387     } catch (std::exception& e) {
64388       {
64389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64390       };
64391     } catch (...) {
64392       {
64393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64394       };
64395     }
64396   }
64397   jresult = (void *)result;
64398   return jresult;
64399 }
64400
64401
64402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64403   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64404   float arg2 ;
64405
64406   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64407   arg2 = (float)jarg2;
64408   if (arg1) (arg1)->left = arg2;
64409 }
64410
64411
64412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64413   float jresult ;
64414   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64415   float result;
64416
64417   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64418   result = (float) ((arg1)->left);
64419   jresult = result;
64420   return jresult;
64421 }
64422
64423
64424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64425   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64426   float arg2 ;
64427
64428   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64429   arg2 = (float)jarg2;
64430   if (arg1) (arg1)->right = arg2;
64431 }
64432
64433
64434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64435   float jresult ;
64436   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64437   float result;
64438
64439   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64440   result = (float) ((arg1)->right);
64441   jresult = result;
64442   return jresult;
64443 }
64444
64445
64446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64447   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64448   float arg2 ;
64449
64450   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64451   arg2 = (float)jarg2;
64452   if (arg1) (arg1)->top = arg2;
64453 }
64454
64455
64456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64457   float jresult ;
64458   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64459   float result;
64460
64461   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64462   result = (float) ((arg1)->top);
64463   jresult = result;
64464   return jresult;
64465 }
64466
64467
64468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64469   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64470   float arg2 ;
64471
64472   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64473   arg2 = (float)jarg2;
64474   if (arg1) (arg1)->bottom = arg2;
64475 }
64476
64477
64478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64479   float jresult ;
64480   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64481   float result;
64482
64483   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64484   result = (float) ((arg1)->bottom);
64485   jresult = result;
64486   return jresult;
64487 }
64488
64489
64490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64491   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64492
64493   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64494   {
64495     try {
64496       delete arg1;
64497     } catch (std::out_of_range& e) {
64498       {
64499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64500       };
64501     } catch (std::exception& e) {
64502       {
64503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64504       };
64505     } catch (...) {
64506       {
64507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64508       };
64509     }
64510   }
64511 }
64512
64513
64514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64515   void * jresult ;
64516   Dali::Toolkit::Alignment *result = 0 ;
64517
64518   {
64519     try {
64520       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64521     } catch (std::out_of_range& e) {
64522       {
64523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64524       };
64525     } catch (std::exception& e) {
64526       {
64527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64528       };
64529     } catch (...) {
64530       {
64531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64532       };
64533     }
64534   }
64535   jresult = (void *)result;
64536   return jresult;
64537 }
64538
64539
64540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64541   void * jresult ;
64542   Dali::Toolkit::Alignment::Type arg1 ;
64543   Dali::Toolkit::Alignment::Type arg2 ;
64544   Dali::Toolkit::Alignment result;
64545
64546   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64547   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64548   {
64549     try {
64550       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64551     } catch (std::out_of_range& e) {
64552       {
64553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64554       };
64555     } catch (std::exception& e) {
64556       {
64557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64558       };
64559     } catch (...) {
64560       {
64561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64562       };
64563     }
64564   }
64565   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64566   return jresult;
64567 }
64568
64569
64570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64571   void * jresult ;
64572   Dali::Toolkit::Alignment::Type arg1 ;
64573   Dali::Toolkit::Alignment result;
64574
64575   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64576   {
64577     try {
64578       result = Dali::Toolkit::Alignment::New(arg1);
64579     } catch (std::out_of_range& e) {
64580       {
64581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64582       };
64583     } catch (std::exception& e) {
64584       {
64585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64586       };
64587     } catch (...) {
64588       {
64589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64590       };
64591     }
64592   }
64593   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64594   return jresult;
64595 }
64596
64597
64598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64599   void * jresult ;
64600   Dali::Toolkit::Alignment result;
64601
64602   {
64603     try {
64604       result = Dali::Toolkit::Alignment::New();
64605     } catch (std::out_of_range& e) {
64606       {
64607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64608       };
64609     } catch (std::exception& e) {
64610       {
64611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64612       };
64613     } catch (...) {
64614       {
64615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64616       };
64617     }
64618   }
64619   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64620   return jresult;
64621 }
64622
64623
64624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64625   void * jresult ;
64626   Dali::Toolkit::Alignment *arg1 = 0 ;
64627   Dali::Toolkit::Alignment *result = 0 ;
64628
64629   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64630   if (!arg1) {
64631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64632     return 0;
64633   }
64634   {
64635     try {
64636       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64637     } catch (std::out_of_range& e) {
64638       {
64639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64640       };
64641     } catch (std::exception& e) {
64642       {
64643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64644       };
64645     } catch (...) {
64646       {
64647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64648       };
64649     }
64650   }
64651   jresult = (void *)result;
64652   return jresult;
64653 }
64654
64655
64656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64657   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64658
64659   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64660   {
64661     try {
64662       delete arg1;
64663     } catch (std::out_of_range& e) {
64664       {
64665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64666       };
64667     } catch (std::exception& e) {
64668       {
64669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64670       };
64671     } catch (...) {
64672       {
64673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64674       };
64675     }
64676   }
64677 }
64678
64679
64680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64681   void * jresult ;
64682   Dali::BaseHandle arg1 ;
64683   Dali::BaseHandle *argp1 ;
64684   Dali::Toolkit::Alignment result;
64685
64686   argp1 = (Dali::BaseHandle *)jarg1;
64687   if (!argp1) {
64688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64689     return 0;
64690   }
64691   arg1 = *argp1;
64692   {
64693     try {
64694       result = Dali::Toolkit::Alignment::DownCast(arg1);
64695     } catch (std::out_of_range& e) {
64696       {
64697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64698       };
64699     } catch (std::exception& e) {
64700       {
64701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64702       };
64703     } catch (...) {
64704       {
64705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64706       };
64707     }
64708   }
64709   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64710   return jresult;
64711 }
64712
64713
64714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64715   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64716   Dali::Toolkit::Alignment::Type arg2 ;
64717
64718   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64719   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64720   {
64721     try {
64722       (arg1)->SetAlignmentType(arg2);
64723     } catch (std::out_of_range& e) {
64724       {
64725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64726       };
64727     } catch (std::exception& e) {
64728       {
64729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64730       };
64731     } catch (...) {
64732       {
64733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64734       };
64735     }
64736   }
64737 }
64738
64739
64740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64741   int jresult ;
64742   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64743   Dali::Toolkit::Alignment::Type result;
64744
64745   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64746   {
64747     try {
64748       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64749     } catch (std::out_of_range& e) {
64750       {
64751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64752       };
64753     } catch (std::exception& e) {
64754       {
64755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64756       };
64757     } catch (...) {
64758       {
64759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64760       };
64761     }
64762   }
64763   jresult = (int)result;
64764   return jresult;
64765 }
64766
64767
64768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64769   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64770   Dali::Toolkit::Alignment::Scaling arg2 ;
64771
64772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64773   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64774   {
64775     try {
64776       (arg1)->SetScaling(arg2);
64777     } catch (std::out_of_range& e) {
64778       {
64779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64780       };
64781     } catch (std::exception& e) {
64782       {
64783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64784       };
64785     } catch (...) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64788       };
64789     }
64790   }
64791 }
64792
64793
64794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64795   int jresult ;
64796   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64797   Dali::Toolkit::Alignment::Scaling result;
64798
64799   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64800   {
64801     try {
64802       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64803     } catch (std::out_of_range& e) {
64804       {
64805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64806       };
64807     } catch (std::exception& e) {
64808       {
64809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64810       };
64811     } catch (...) {
64812       {
64813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64814       };
64815     }
64816   }
64817   jresult = (int)result;
64818   return jresult;
64819 }
64820
64821
64822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64823   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64824   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64825
64826   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64827   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64828   if (!arg2) {
64829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64830     return ;
64831   }
64832   {
64833     try {
64834       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64835     } catch (std::out_of_range& e) {
64836       {
64837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64838       };
64839     } catch (std::exception& e) {
64840       {
64841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64842       };
64843     } catch (...) {
64844       {
64845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64846       };
64847     }
64848   }
64849 }
64850
64851
64852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64853   void * jresult ;
64854   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64855   Dali::Toolkit::Alignment::Padding *result = 0 ;
64856
64857   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64858   {
64859     try {
64860       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64861     } catch (std::out_of_range& e) {
64862       {
64863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64864       };
64865     } catch (std::exception& e) {
64866       {
64867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64868       };
64869     } catch (...) {
64870       {
64871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64872       };
64873     }
64874   }
64875   jresult = (void *)result;
64876   return jresult;
64877 }
64878
64879
64880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64881   void * jresult ;
64882   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64883   Dali::Toolkit::Alignment *arg2 = 0 ;
64884   Dali::Toolkit::Alignment *result = 0 ;
64885
64886   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64887   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64888   if (!arg2) {
64889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64890     return 0;
64891   }
64892   {
64893     try {
64894       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64895     } catch (std::out_of_range& e) {
64896       {
64897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64898       };
64899     } catch (std::exception& e) {
64900       {
64901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64902       };
64903     } catch (...) {
64904       {
64905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64906       };
64907     }
64908   }
64909   jresult = (void *)result;
64910   return jresult;
64911 }
64912
64913
64914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64915   int jresult ;
64916   int result;
64917
64918   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64919   jresult = (int)result;
64920   return jresult;
64921 }
64922
64923
64924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64925   int jresult ;
64926   int result;
64927
64928   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64929   jresult = (int)result;
64930   return jresult;
64931 }
64932
64933
64934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64935   int jresult ;
64936   int result;
64937
64938   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64939   jresult = (int)result;
64940   return jresult;
64941 }
64942
64943
64944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64945   int jresult ;
64946   int result;
64947
64948   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64949   jresult = (int)result;
64950   return jresult;
64951 }
64952
64953
64954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64955   int jresult ;
64956   int result;
64957
64958   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64959   jresult = (int)result;
64960   return jresult;
64961 }
64962
64963
64964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64965   int jresult ;
64966   int result;
64967
64968   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64969   jresult = (int)result;
64970   return jresult;
64971 }
64972
64973
64974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64975   int jresult ;
64976   int result;
64977
64978   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64979   jresult = (int)result;
64980   return jresult;
64981 }
64982
64983
64984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64985   int jresult ;
64986   int result;
64987
64988   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64989   jresult = (int)result;
64990   return jresult;
64991 }
64992
64993
64994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64995   int jresult ;
64996   int result;
64997
64998   result = (int)Dali::Toolkit::Button::Property::LABEL;
64999   jresult = (int)result;
65000   return jresult;
65001 }
65002
65003
65004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65005   int jresult ;
65006   int result;
65007
65008   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65009   jresult = (int)result;
65010   return jresult;
65011 }
65012
65013
65014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65015   void * jresult ;
65016   Dali::Toolkit::Button::Property *result = 0 ;
65017
65018   {
65019     try {
65020       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65021     } catch (std::out_of_range& e) {
65022       {
65023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65024       };
65025     } catch (std::exception& e) {
65026       {
65027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65028       };
65029     } catch (...) {
65030       {
65031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65032       };
65033     }
65034   }
65035   jresult = (void *)result;
65036   return jresult;
65037 }
65038
65039
65040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65041   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65042
65043   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65044   {
65045     try {
65046       delete arg1;
65047     } catch (std::out_of_range& e) {
65048       {
65049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65050       };
65051     } catch (std::exception& e) {
65052       {
65053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65054       };
65055     } catch (...) {
65056       {
65057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65058       };
65059     }
65060   }
65061 }
65062
65063
65064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65065   void * jresult ;
65066   Dali::Toolkit::Button *result = 0 ;
65067
65068   {
65069     try {
65070       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65071     } catch (std::out_of_range& e) {
65072       {
65073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65074       };
65075     } catch (std::exception& e) {
65076       {
65077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65078       };
65079     } catch (...) {
65080       {
65081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65082       };
65083     }
65084   }
65085   jresult = (void *)result;
65086   return jresult;
65087 }
65088
65089
65090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65091   void * jresult ;
65092   Dali::Toolkit::Button *arg1 = 0 ;
65093   Dali::Toolkit::Button *result = 0 ;
65094
65095   arg1 = (Dali::Toolkit::Button *)jarg1;
65096   if (!arg1) {
65097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65098     return 0;
65099   }
65100   {
65101     try {
65102       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65103     } catch (std::out_of_range& e) {
65104       {
65105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65106       };
65107     } catch (std::exception& e) {
65108       {
65109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65110       };
65111     } catch (...) {
65112       {
65113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65114       };
65115     }
65116   }
65117   jresult = (void *)result;
65118   return jresult;
65119 }
65120
65121
65122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65123   void * jresult ;
65124   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65125   Dali::Toolkit::Button *arg2 = 0 ;
65126   Dali::Toolkit::Button *result = 0 ;
65127
65128   arg1 = (Dali::Toolkit::Button *)jarg1;
65129   arg2 = (Dali::Toolkit::Button *)jarg2;
65130   if (!arg2) {
65131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65132     return 0;
65133   }
65134   {
65135     try {
65136       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65137     } catch (std::out_of_range& e) {
65138       {
65139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65140       };
65141     } catch (std::exception& e) {
65142       {
65143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65144       };
65145     } catch (...) {
65146       {
65147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65148       };
65149     }
65150   }
65151   jresult = (void *)result;
65152   return jresult;
65153 }
65154
65155
65156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65157   void * jresult ;
65158   Dali::BaseHandle arg1 ;
65159   Dali::BaseHandle *argp1 ;
65160   Dali::Toolkit::Button result;
65161
65162   argp1 = (Dali::BaseHandle *)jarg1;
65163   if (!argp1) {
65164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65165     return 0;
65166   }
65167   arg1 = *argp1;
65168   {
65169     try {
65170       result = Dali::Toolkit::Button::DownCast(arg1);
65171     } catch (std::out_of_range& e) {
65172       {
65173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (std::exception& e) {
65176       {
65177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (...) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65182       };
65183     }
65184   }
65185   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65186   return jresult;
65187 }
65188
65189
65190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65191   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65192
65193   arg1 = (Dali::Toolkit::Button *)jarg1;
65194   {
65195     try {
65196       delete arg1;
65197     } catch (std::out_of_range& e) {
65198       {
65199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65200       };
65201     } catch (std::exception& e) {
65202       {
65203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65204       };
65205     } catch (...) {
65206       {
65207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65208       };
65209     }
65210   }
65211 }
65212
65213
65214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65215   unsigned int jresult ;
65216   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65217   bool result;
65218
65219   arg1 = (Dali::Toolkit::Button *)jarg1;
65220   {
65221     try {
65222       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65223     } catch (std::out_of_range& e) {
65224       {
65225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (std::exception& e) {
65228       {
65229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (...) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65234       };
65235     }
65236   }
65237   jresult = result;
65238   return jresult;
65239 }
65240
65241
65242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65243   unsigned int jresult ;
65244   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65245   bool result;
65246
65247   arg1 = (Dali::Toolkit::Button *)jarg1;
65248   {
65249     try {
65250       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65251     } catch (std::out_of_range& e) {
65252       {
65253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65254       };
65255     } catch (std::exception& e) {
65256       {
65257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65258       };
65259     } catch (...) {
65260       {
65261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65262       };
65263     }
65264   }
65265   jresult = result;
65266   return jresult;
65267 }
65268
65269
65270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65271   float jresult ;
65272   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65273   float result;
65274
65275   arg1 = (Dali::Toolkit::Button *)jarg1;
65276   {
65277     try {
65278       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65279     } catch (std::out_of_range& e) {
65280       {
65281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65282       };
65283     } catch (std::exception& e) {
65284       {
65285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65286       };
65287     } catch (...) {
65288       {
65289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65290       };
65291     }
65292   }
65293   jresult = result;
65294   return jresult;
65295 }
65296
65297
65298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65299   float jresult ;
65300   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65301   float result;
65302
65303   arg1 = (Dali::Toolkit::Button *)jarg1;
65304   {
65305     try {
65306       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65307     } catch (std::out_of_range& e) {
65308       {
65309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65310       };
65311     } catch (std::exception& e) {
65312       {
65313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (...) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65318       };
65319     }
65320   }
65321   jresult = result;
65322   return jresult;
65323 }
65324
65325
65326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65327   unsigned int jresult ;
65328   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65329   bool result;
65330
65331   arg1 = (Dali::Toolkit::Button *)jarg1;
65332   {
65333     try {
65334       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65335     } catch (std::out_of_range& e) {
65336       {
65337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65338       };
65339     } catch (std::exception& e) {
65340       {
65341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65342       };
65343     } catch (...) {
65344       {
65345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65346       };
65347     }
65348   }
65349   jresult = result;
65350   return jresult;
65351 }
65352
65353
65354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65355   unsigned int jresult ;
65356   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65357   bool result;
65358
65359   arg1 = (Dali::Toolkit::Button *)jarg1;
65360   {
65361     try {
65362       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65363     } catch (std::out_of_range& e) {
65364       {
65365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65366       };
65367     } catch (std::exception& e) {
65368       {
65369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65370       };
65371     } catch (...) {
65372       {
65373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65374       };
65375     }
65376   }
65377   jresult = result;
65378   return jresult;
65379 }
65380
65381
65382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65383   float jresult ;
65384   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65385   float result;
65386
65387   arg1 = (Dali::Toolkit::Button *)jarg1;
65388   {
65389     try {
65390       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65391     } catch (std::out_of_range& e) {
65392       {
65393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65394       };
65395     } catch (std::exception& e) {
65396       {
65397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65398       };
65399     } catch (...) {
65400       {
65401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65402       };
65403     }
65404   }
65405   jresult = result;
65406   return jresult;
65407 }
65408
65409
65410 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65411   char * jresult ;
65412   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65413   std::string result;
65414
65415   arg1 = (Dali::Toolkit::Button *)jarg1;
65416   {
65417     try {
65418       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65419     } catch (std::out_of_range& e) {
65420       {
65421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65422       };
65423     } catch (std::exception& e) {
65424       {
65425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (...) {
65428       {
65429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65430       };
65431     }
65432   }
65433   jresult = SWIG_csharp_string_callback((&result)->c_str());
65434   return jresult;
65435 }
65436
65437
65438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65439   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65440   Dali::Actor arg2 ;
65441   Dali::Actor *argp2 ;
65442
65443   arg1 = (Dali::Toolkit::Button *)jarg1;
65444   argp2 = (Dali::Actor *)jarg2;
65445   if (!argp2) {
65446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65447     return ;
65448   }
65449   arg2 = *argp2;
65450   {
65451     try {
65452       (arg1)->SetLabel(arg2);
65453     } catch (std::out_of_range& e) {
65454       {
65455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65456       };
65457     } catch (std::exception& e) {
65458       {
65459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65460       };
65461     } catch (...) {
65462       {
65463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65464       };
65465     }
65466   }
65467 }
65468
65469
65470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65471   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65472   Dali::Image arg2 ;
65473   Dali::Image *argp2 ;
65474
65475   arg1 = (Dali::Toolkit::Button *)jarg1;
65476   argp2 = (Dali::Image *)jarg2;
65477   if (!argp2) {
65478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65479     return ;
65480   }
65481   arg2 = *argp2;
65482   {
65483     try {
65484       (arg1)->SetButtonImage(arg2);
65485     } catch (std::out_of_range& e) {
65486       {
65487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65488       };
65489     } catch (std::exception& e) {
65490       {
65491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65492       };
65493     } catch (...) {
65494       {
65495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65496       };
65497     }
65498   }
65499 }
65500
65501
65502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65503   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65504   Dali::Image arg2 ;
65505   Dali::Image *argp2 ;
65506
65507   arg1 = (Dali::Toolkit::Button *)jarg1;
65508   argp2 = (Dali::Image *)jarg2;
65509   if (!argp2) {
65510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65511     return ;
65512   }
65513   arg2 = *argp2;
65514   {
65515     try {
65516       (arg1)->SetSelectedImage(arg2);
65517     } catch (std::out_of_range& e) {
65518       {
65519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65520       };
65521     } catch (std::exception& e) {
65522       {
65523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65524       };
65525     } catch (...) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65528       };
65529     }
65530   }
65531 }
65532
65533
65534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65535   void * jresult ;
65536   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65537   Dali::Actor result;
65538
65539   arg1 = (Dali::Toolkit::Button *)jarg1;
65540   {
65541     try {
65542       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65543     } catch (std::out_of_range& e) {
65544       {
65545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65546       };
65547     } catch (std::exception& e) {
65548       {
65549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65550       };
65551     } catch (...) {
65552       {
65553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65554       };
65555     }
65556   }
65557   jresult = new Dali::Actor((const Dali::Actor &)result);
65558   return jresult;
65559 }
65560
65561
65562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65563   void * jresult ;
65564   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65565   Dali::Actor result;
65566
65567   arg1 = (Dali::Toolkit::Button *)jarg1;
65568   {
65569     try {
65570       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65571     } catch (std::out_of_range& e) {
65572       {
65573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65574       };
65575     } catch (std::exception& e) {
65576       {
65577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65578       };
65579     } catch (...) {
65580       {
65581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65582       };
65583     }
65584   }
65585   jresult = new Dali::Actor((const Dali::Actor &)result);
65586   return jresult;
65587 }
65588
65589
65590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65591   void * jresult ;
65592   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65593   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65594
65595   arg1 = (Dali::Toolkit::Button *)jarg1;
65596   {
65597     try {
65598       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65599     } catch (std::out_of_range& e) {
65600       {
65601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65602       };
65603     } catch (std::exception& e) {
65604       {
65605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65606       };
65607     } catch (...) {
65608       {
65609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65610       };
65611     }
65612   }
65613   jresult = (void *)result;
65614   return jresult;
65615 }
65616
65617
65618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65619   void * jresult ;
65620   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65621   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65622
65623   arg1 = (Dali::Toolkit::Button *)jarg1;
65624   {
65625     try {
65626       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65627     } catch (std::out_of_range& e) {
65628       {
65629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65630       };
65631     } catch (std::exception& e) {
65632       {
65633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65634       };
65635     } catch (...) {
65636       {
65637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65638       };
65639     }
65640   }
65641   jresult = (void *)result;
65642   return jresult;
65643 }
65644
65645
65646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65647   void * jresult ;
65648   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65649   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65650
65651   arg1 = (Dali::Toolkit::Button *)jarg1;
65652   {
65653     try {
65654       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (...) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65666       };
65667     }
65668   }
65669   jresult = (void *)result;
65670   return jresult;
65671 }
65672
65673
65674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65675   void * jresult ;
65676   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65677   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65678
65679   arg1 = (Dali::Toolkit::Button *)jarg1;
65680   {
65681     try {
65682       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65683     } catch (std::out_of_range& e) {
65684       {
65685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65686       };
65687     } catch (std::exception& e) {
65688       {
65689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (...) {
65692       {
65693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65694       };
65695     }
65696   }
65697   jresult = (void *)result;
65698   return jresult;
65699 }
65700
65701
65702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65703   void * jresult ;
65704   Dali::Toolkit::CheckBoxButton *result = 0 ;
65705
65706   {
65707     try {
65708       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65709     } catch (std::out_of_range& e) {
65710       {
65711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65712       };
65713     } catch (std::exception& e) {
65714       {
65715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65716       };
65717     } catch (...) {
65718       {
65719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65720       };
65721     }
65722   }
65723   jresult = (void *)result;
65724   return jresult;
65725 }
65726
65727
65728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65729   void * jresult ;
65730   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65731   Dali::Toolkit::CheckBoxButton *result = 0 ;
65732
65733   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65734   if (!arg1) {
65735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65736     return 0;
65737   }
65738   {
65739     try {
65740       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65741     } catch (std::out_of_range& e) {
65742       {
65743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65744       };
65745     } catch (std::exception& e) {
65746       {
65747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65748       };
65749     } catch (...) {
65750       {
65751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65752       };
65753     }
65754   }
65755   jresult = (void *)result;
65756   return jresult;
65757 }
65758
65759
65760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65761   void * jresult ;
65762   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65763   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65764   Dali::Toolkit::CheckBoxButton *result = 0 ;
65765
65766   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65767   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65768   if (!arg2) {
65769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65770     return 0;
65771   }
65772   {
65773     try {
65774       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65775     } catch (std::out_of_range& e) {
65776       {
65777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65778       };
65779     } catch (std::exception& e) {
65780       {
65781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65782       };
65783     } catch (...) {
65784       {
65785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65786       };
65787     }
65788   }
65789   jresult = (void *)result;
65790   return jresult;
65791 }
65792
65793
65794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65795   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65796
65797   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65798   {
65799     try {
65800       delete arg1;
65801     } catch (std::out_of_range& e) {
65802       {
65803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65804       };
65805     } catch (std::exception& e) {
65806       {
65807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65808       };
65809     } catch (...) {
65810       {
65811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65812       };
65813     }
65814   }
65815 }
65816
65817
65818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65819   void * jresult ;
65820   Dali::Toolkit::CheckBoxButton result;
65821
65822   {
65823     try {
65824       result = Dali::Toolkit::CheckBoxButton::New();
65825     } catch (std::out_of_range& e) {
65826       {
65827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65828       };
65829     } catch (std::exception& e) {
65830       {
65831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65832       };
65833     } catch (...) {
65834       {
65835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65836       };
65837     }
65838   }
65839   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65840   return jresult;
65841 }
65842
65843
65844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65845   void * jresult ;
65846   Dali::BaseHandle arg1 ;
65847   Dali::BaseHandle *argp1 ;
65848   Dali::Toolkit::CheckBoxButton result;
65849
65850   argp1 = (Dali::BaseHandle *)jarg1;
65851   if (!argp1) {
65852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65853     return 0;
65854   }
65855   arg1 = *argp1;
65856   {
65857     try {
65858       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65859     } catch (std::out_of_range& e) {
65860       {
65861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (std::exception& e) {
65864       {
65865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65866       };
65867     } catch (...) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65870       };
65871     }
65872   }
65873   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65874   return jresult;
65875 }
65876
65877
65878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
65879   int jresult ;
65880   int result;
65881
65882   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
65883   jresult = (int)result;
65884   return jresult;
65885 }
65886
65887
65888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
65889   int jresult ;
65890   int result;
65891
65892   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
65893   jresult = (int)result;
65894   return jresult;
65895 }
65896
65897
65898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
65899   int jresult ;
65900   int result;
65901
65902   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
65903   jresult = (int)result;
65904   return jresult;
65905 }
65906
65907
65908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65909   int jresult ;
65910   int result;
65911
65912   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65913   jresult = (int)result;
65914   return jresult;
65915 }
65916
65917
65918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65919   int jresult ;
65920   int result;
65921
65922   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65923   jresult = (int)result;
65924   return jresult;
65925 }
65926
65927
65928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65929   void * jresult ;
65930   Dali::Toolkit::PushButton::Property *result = 0 ;
65931
65932   {
65933     try {
65934       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65935     } catch (std::out_of_range& e) {
65936       {
65937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65938       };
65939     } catch (std::exception& e) {
65940       {
65941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65942       };
65943     } catch (...) {
65944       {
65945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65946       };
65947     }
65948   }
65949   jresult = (void *)result;
65950   return jresult;
65951 }
65952
65953
65954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65955   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65956
65957   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65958   {
65959     try {
65960       delete arg1;
65961     } catch (std::out_of_range& e) {
65962       {
65963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65964       };
65965     } catch (std::exception& e) {
65966       {
65967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65968       };
65969     } catch (...) {
65970       {
65971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65972       };
65973     }
65974   }
65975 }
65976
65977
65978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65979   void * jresult ;
65980   Dali::Toolkit::PushButton *result = 0 ;
65981
65982   {
65983     try {
65984       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65985     } catch (std::out_of_range& e) {
65986       {
65987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65988       };
65989     } catch (std::exception& e) {
65990       {
65991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65992       };
65993     } catch (...) {
65994       {
65995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65996       };
65997     }
65998   }
65999   jresult = (void *)result;
66000   return jresult;
66001 }
66002
66003
66004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66005   void * jresult ;
66006   Dali::Toolkit::PushButton *arg1 = 0 ;
66007   Dali::Toolkit::PushButton *result = 0 ;
66008
66009   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66010   if (!arg1) {
66011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66012     return 0;
66013   }
66014   {
66015     try {
66016       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66017     } catch (std::out_of_range& e) {
66018       {
66019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66020       };
66021     } catch (std::exception& e) {
66022       {
66023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66024       };
66025     } catch (...) {
66026       {
66027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66028       };
66029     }
66030   }
66031   jresult = (void *)result;
66032   return jresult;
66033 }
66034
66035
66036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66037   void * jresult ;
66038   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66039   Dali::Toolkit::PushButton *arg2 = 0 ;
66040   Dali::Toolkit::PushButton *result = 0 ;
66041
66042   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66043   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66044   if (!arg2) {
66045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66046     return 0;
66047   }
66048   {
66049     try {
66050       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66051     } catch (std::out_of_range& e) {
66052       {
66053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66054       };
66055     } catch (std::exception& e) {
66056       {
66057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66058       };
66059     } catch (...) {
66060       {
66061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66062       };
66063     }
66064   }
66065   jresult = (void *)result;
66066   return jresult;
66067 }
66068
66069
66070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66071   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66072
66073   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66074   {
66075     try {
66076       delete arg1;
66077     } catch (std::out_of_range& e) {
66078       {
66079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66080       };
66081     } catch (std::exception& e) {
66082       {
66083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66084       };
66085     } catch (...) {
66086       {
66087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66088       };
66089     }
66090   }
66091 }
66092
66093
66094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66095   void * jresult ;
66096   Dali::Toolkit::PushButton result;
66097
66098   {
66099     try {
66100       result = Dali::Toolkit::PushButton::New();
66101     } catch (std::out_of_range& e) {
66102       {
66103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66104       };
66105     } catch (std::exception& e) {
66106       {
66107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66108       };
66109     } catch (...) {
66110       {
66111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66112       };
66113     }
66114   }
66115   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66116   return jresult;
66117 }
66118
66119
66120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66121   void * jresult ;
66122   Dali::BaseHandle arg1 ;
66123   Dali::BaseHandle *argp1 ;
66124   Dali::Toolkit::PushButton result;
66125
66126   argp1 = (Dali::BaseHandle *)jarg1;
66127   if (!argp1) {
66128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66129     return 0;
66130   }
66131   arg1 = *argp1;
66132   {
66133     try {
66134       result = Dali::Toolkit::PushButton::DownCast(arg1);
66135     } catch (std::out_of_range& e) {
66136       {
66137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66138       };
66139     } catch (std::exception& e) {
66140       {
66141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66142       };
66143     } catch (...) {
66144       {
66145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66146       };
66147     }
66148   }
66149   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66150   return jresult;
66151 }
66152
66153
66154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66155   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66156   Dali::Image arg2 ;
66157   Dali::Image *argp2 ;
66158
66159   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66160   argp2 = (Dali::Image *)jarg2;
66161   if (!argp2) {
66162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66163     return ;
66164   }
66165   arg2 = *argp2;
66166   {
66167     try {
66168       (arg1)->SetButtonImage(arg2);
66169     } catch (std::out_of_range& e) {
66170       {
66171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66172       };
66173     } catch (std::exception& e) {
66174       {
66175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66176       };
66177     } catch (...) {
66178       {
66179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66180       };
66181     }
66182   }
66183 }
66184
66185
66186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66187   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66188   Dali::Actor arg2 ;
66189   Dali::Actor *argp2 ;
66190
66191   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66192   argp2 = (Dali::Actor *)jarg2;
66193   if (!argp2) {
66194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66195     return ;
66196   }
66197   arg2 = *argp2;
66198   {
66199     try {
66200       (arg1)->SetButtonImage(arg2);
66201     } catch (std::out_of_range& e) {
66202       {
66203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66204       };
66205     } catch (std::exception& e) {
66206       {
66207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (...) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66212       };
66213     }
66214   }
66215 }
66216
66217
66218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66219   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66220   Dali::Actor arg2 ;
66221   Dali::Actor *argp2 ;
66222
66223   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66224   argp2 = (Dali::Actor *)jarg2;
66225   if (!argp2) {
66226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66227     return ;
66228   }
66229   arg2 = *argp2;
66230   {
66231     try {
66232       (arg1)->SetBackgroundImage(arg2);
66233     } catch (std::out_of_range& e) {
66234       {
66235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66236       };
66237     } catch (std::exception& e) {
66238       {
66239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66240       };
66241     } catch (...) {
66242       {
66243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66244       };
66245     }
66246   }
66247 }
66248
66249
66250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66251   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66252   Dali::Image arg2 ;
66253   Dali::Image *argp2 ;
66254
66255   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66256   argp2 = (Dali::Image *)jarg2;
66257   if (!argp2) {
66258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66259     return ;
66260   }
66261   arg2 = *argp2;
66262   {
66263     try {
66264       (arg1)->SetSelectedImage(arg2);
66265     } catch (std::out_of_range& e) {
66266       {
66267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66268       };
66269     } catch (std::exception& e) {
66270       {
66271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66272       };
66273     } catch (...) {
66274       {
66275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66276       };
66277     }
66278   }
66279 }
66280
66281
66282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66283   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66284   Dali::Actor arg2 ;
66285   Dali::Actor *argp2 ;
66286
66287   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66288   argp2 = (Dali::Actor *)jarg2;
66289   if (!argp2) {
66290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66291     return ;
66292   }
66293   arg2 = *argp2;
66294   {
66295     try {
66296       (arg1)->SetSelectedImage(arg2);
66297     } catch (std::out_of_range& e) {
66298       {
66299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66300       };
66301     } catch (std::exception& e) {
66302       {
66303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66304       };
66305     } catch (...) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66308       };
66309     }
66310   }
66311 }
66312
66313
66314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66315   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66316   Dali::Actor arg2 ;
66317   Dali::Actor *argp2 ;
66318
66319   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66320   argp2 = (Dali::Actor *)jarg2;
66321   if (!argp2) {
66322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66323     return ;
66324   }
66325   arg2 = *argp2;
66326   {
66327     try {
66328       (arg1)->SetSelectedBackgroundImage(arg2);
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66340       };
66341     }
66342   }
66343 }
66344
66345
66346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66347   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66348   Dali::Actor arg2 ;
66349   Dali::Actor *argp2 ;
66350
66351   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66352   argp2 = (Dali::Actor *)jarg2;
66353   if (!argp2) {
66354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66355     return ;
66356   }
66357   arg2 = *argp2;
66358   {
66359     try {
66360       (arg1)->SetDisabledBackgroundImage(arg2);
66361     } catch (std::out_of_range& e) {
66362       {
66363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66364       };
66365     } catch (std::exception& e) {
66366       {
66367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66368       };
66369     } catch (...) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66372       };
66373     }
66374   }
66375 }
66376
66377
66378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66379   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66380   Dali::Actor arg2 ;
66381   Dali::Actor *argp2 ;
66382
66383   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66384   argp2 = (Dali::Actor *)jarg2;
66385   if (!argp2) {
66386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66387     return ;
66388   }
66389   arg2 = *argp2;
66390   {
66391     try {
66392       (arg1)->SetDisabledImage(arg2);
66393     } catch (std::out_of_range& e) {
66394       {
66395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (std::exception& e) {
66398       {
66399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66404       };
66405     }
66406   }
66407 }
66408
66409
66410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66411   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66412   Dali::Actor arg2 ;
66413   Dali::Actor *argp2 ;
66414
66415   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66416   argp2 = (Dali::Actor *)jarg2;
66417   if (!argp2) {
66418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66419     return ;
66420   }
66421   arg2 = *argp2;
66422   {
66423     try {
66424       (arg1)->SetDisabledSelectedImage(arg2);
66425     } catch (std::out_of_range& e) {
66426       {
66427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66428       };
66429     } catch (std::exception& e) {
66430       {
66431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66432       };
66433     } catch (...) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66436       };
66437     }
66438   }
66439 }
66440
66441
66442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66443   void * jresult ;
66444   Dali::Toolkit::RadioButton *result = 0 ;
66445
66446   {
66447     try {
66448       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66449     } catch (std::out_of_range& e) {
66450       {
66451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66452       };
66453     } catch (std::exception& e) {
66454       {
66455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66456       };
66457     } catch (...) {
66458       {
66459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66460       };
66461     }
66462   }
66463   jresult = (void *)result;
66464   return jresult;
66465 }
66466
66467
66468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66469   void * jresult ;
66470   Dali::Toolkit::RadioButton *arg1 = 0 ;
66471   Dali::Toolkit::RadioButton *result = 0 ;
66472
66473   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66474   if (!arg1) {
66475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66476     return 0;
66477   }
66478   {
66479     try {
66480       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66481     } catch (std::out_of_range& e) {
66482       {
66483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66484       };
66485     } catch (std::exception& e) {
66486       {
66487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66488       };
66489     } catch (...) {
66490       {
66491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66492       };
66493     }
66494   }
66495   jresult = (void *)result;
66496   return jresult;
66497 }
66498
66499
66500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66501   void * jresult ;
66502   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66503   Dali::Toolkit::RadioButton *arg2 = 0 ;
66504   Dali::Toolkit::RadioButton *result = 0 ;
66505
66506   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66507   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66508   if (!arg2) {
66509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66510     return 0;
66511   }
66512   {
66513     try {
66514       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529   jresult = (void *)result;
66530   return jresult;
66531 }
66532
66533
66534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66535   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66536
66537   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66538   {
66539     try {
66540       delete arg1;
66541     } catch (std::out_of_range& e) {
66542       {
66543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66544       };
66545     } catch (std::exception& e) {
66546       {
66547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66548       };
66549     } catch (...) {
66550       {
66551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66552       };
66553     }
66554   }
66555 }
66556
66557
66558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66559   void * jresult ;
66560   Dali::Toolkit::RadioButton result;
66561
66562   {
66563     try {
66564       result = Dali::Toolkit::RadioButton::New();
66565     } catch (std::out_of_range& e) {
66566       {
66567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66568       };
66569     } catch (std::exception& e) {
66570       {
66571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66572       };
66573     } catch (...) {
66574       {
66575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66576       };
66577     }
66578   }
66579   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66580   return jresult;
66581 }
66582
66583
66584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66585   void * jresult ;
66586   std::string *arg1 = 0 ;
66587   Dali::Toolkit::RadioButton result;
66588
66589   if (!jarg1) {
66590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66591     return 0;
66592   }
66593   std::string arg1_str(jarg1);
66594   arg1 = &arg1_str;
66595   {
66596     try {
66597       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66598     } catch (std::out_of_range& e) {
66599       {
66600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66601       };
66602     } catch (std::exception& e) {
66603       {
66604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66605       };
66606     } catch (...) {
66607       {
66608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66609       };
66610     }
66611   }
66612   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66613
66614   //argout typemap for const std::string&
66615
66616   return jresult;
66617 }
66618
66619
66620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66621   void * jresult ;
66622   Dali::BaseHandle arg1 ;
66623   Dali::BaseHandle *argp1 ;
66624   Dali::Toolkit::RadioButton result;
66625
66626   argp1 = (Dali::BaseHandle *)jarg1;
66627   if (!argp1) {
66628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66629     return 0;
66630   }
66631   arg1 = *argp1;
66632   {
66633     try {
66634       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66635     } catch (std::out_of_range& e) {
66636       {
66637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66638       };
66639     } catch (std::exception& e) {
66640       {
66641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66642       };
66643     } catch (...) {
66644       {
66645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66646       };
66647     }
66648   }
66649   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66650   return jresult;
66651 }
66652
66653
66654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66655   int jresult ;
66656   int result;
66657
66658   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66659   jresult = (int)result;
66660   return jresult;
66661 }
66662
66663
66664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66665   int jresult ;
66666   int result;
66667
66668   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66669   jresult = (int)result;
66670   return jresult;
66671 }
66672
66673
66674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66675   int jresult ;
66676   int result;
66677
66678   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66679   jresult = (int)result;
66680   return jresult;
66681 }
66682
66683
66684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66685   int jresult ;
66686   int result;
66687
66688   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66689   jresult = (int)result;
66690   return jresult;
66691 }
66692
66693
66694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66695   int jresult ;
66696   int result;
66697
66698   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66699   jresult = (int)result;
66700   return jresult;
66701 }
66702
66703
66704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66705   int jresult ;
66706   int result;
66707
66708   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66709   jresult = (int)result;
66710   return jresult;
66711 }
66712
66713
66714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66715   void * jresult ;
66716   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66717
66718   {
66719     try {
66720       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66721     } catch (std::out_of_range& e) {
66722       {
66723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66724       };
66725     } catch (std::exception& e) {
66726       {
66727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66728       };
66729     } catch (...) {
66730       {
66731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66732       };
66733     }
66734   }
66735   jresult = (void *)result;
66736   return jresult;
66737 }
66738
66739
66740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66741   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66742
66743   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66744   {
66745     try {
66746       delete arg1;
66747     } catch (std::out_of_range& e) {
66748       {
66749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66750       };
66751     } catch (std::exception& e) {
66752       {
66753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66754       };
66755     } catch (...) {
66756       {
66757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66758       };
66759     }
66760   }
66761 }
66762
66763
66764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66765   int jresult ;
66766   int result;
66767
66768   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66769   jresult = (int)result;
66770   return jresult;
66771 }
66772
66773
66774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66775   int jresult ;
66776   int result;
66777
66778   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66779   jresult = (int)result;
66780   return jresult;
66781 }
66782
66783
66784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66785   int jresult ;
66786   int result;
66787
66788   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66789   jresult = (int)result;
66790   return jresult;
66791 }
66792
66793
66794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66795   void * jresult ;
66796   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66797
66798   {
66799     try {
66800       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66801     } catch (std::out_of_range& e) {
66802       {
66803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66804       };
66805     } catch (std::exception& e) {
66806       {
66807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66808       };
66809     } catch (...) {
66810       {
66811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66812       };
66813     }
66814   }
66815   jresult = (void *)result;
66816   return jresult;
66817 }
66818
66819
66820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66821   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66822
66823   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66824   {
66825     try {
66826       delete arg1;
66827     } catch (std::out_of_range& e) {
66828       {
66829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66830       };
66831     } catch (std::exception& e) {
66832       {
66833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66834       };
66835     } catch (...) {
66836       {
66837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66838       };
66839     }
66840   }
66841 }
66842
66843
66844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66845   void * jresult ;
66846   Dali::Toolkit::FlexContainer *result = 0 ;
66847
66848   {
66849     try {
66850       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66851     } catch (std::out_of_range& e) {
66852       {
66853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66854       };
66855     } catch (std::exception& e) {
66856       {
66857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66858       };
66859     } catch (...) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66862       };
66863     }
66864   }
66865   jresult = (void *)result;
66866   return jresult;
66867 }
66868
66869
66870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66871   void * jresult ;
66872   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66873   Dali::Toolkit::FlexContainer *result = 0 ;
66874
66875   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66876   if (!arg1) {
66877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66878     return 0;
66879   }
66880   {
66881     try {
66882       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66890       };
66891     } catch (...) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66894       };
66895     }
66896   }
66897   jresult = (void *)result;
66898   return jresult;
66899 }
66900
66901
66902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66903   void * jresult ;
66904   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66905   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66906   Dali::Toolkit::FlexContainer *result = 0 ;
66907
66908   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66909   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66910   if (!arg2) {
66911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66912     return 0;
66913   }
66914   {
66915     try {
66916       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66917     } catch (std::out_of_range& e) {
66918       {
66919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66920       };
66921     } catch (std::exception& e) {
66922       {
66923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66924       };
66925     } catch (...) {
66926       {
66927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66928       };
66929     }
66930   }
66931   jresult = (void *)result;
66932   return jresult;
66933 }
66934
66935
66936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66937   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66938
66939   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66940   {
66941     try {
66942       delete arg1;
66943     } catch (std::out_of_range& e) {
66944       {
66945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66946       };
66947     } catch (std::exception& e) {
66948       {
66949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66950       };
66951     } catch (...) {
66952       {
66953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66954       };
66955     }
66956   }
66957 }
66958
66959
66960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66961   void * jresult ;
66962   Dali::Toolkit::FlexContainer result;
66963
66964   {
66965     try {
66966       result = Dali::Toolkit::FlexContainer::New();
66967     } catch (std::out_of_range& e) {
66968       {
66969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66970       };
66971     } catch (std::exception& e) {
66972       {
66973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66974       };
66975     } catch (...) {
66976       {
66977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66978       };
66979     }
66980   }
66981   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66982   return jresult;
66983 }
66984
66985
66986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66987   void * jresult ;
66988   Dali::BaseHandle arg1 ;
66989   Dali::BaseHandle *argp1 ;
66990   Dali::Toolkit::FlexContainer result;
66991
66992   argp1 = (Dali::BaseHandle *)jarg1;
66993   if (!argp1) {
66994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66995     return 0;
66996   }
66997   arg1 = *argp1;
66998   {
66999     try {
67000       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67001     } catch (std::out_of_range& e) {
67002       {
67003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67004       };
67005     } catch (std::exception& e) {
67006       {
67007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67008       };
67009     } catch (...) {
67010       {
67011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67012       };
67013     }
67014   }
67015   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67016   return jresult;
67017 }
67018
67019
67020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67021   int jresult ;
67022   int result;
67023
67024   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67025   jresult = (int)result;
67026   return jresult;
67027 }
67028
67029
67030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67031   int jresult ;
67032   int result;
67033
67034   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67035   jresult = (int)result;
67036   return jresult;
67037 }
67038
67039
67040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67041   int jresult ;
67042   int result;
67043
67044   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67045   jresult = (int)result;
67046   return jresult;
67047 }
67048
67049
67050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67051   int jresult ;
67052   int result;
67053
67054   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67055   jresult = (int)result;
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67061   void * jresult ;
67062   Dali::Toolkit::ImageView::Property *result = 0 ;
67063
67064   {
67065     try {
67066       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67067     } catch (std::out_of_range& e) {
67068       {
67069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67070       };
67071     } catch (std::exception& e) {
67072       {
67073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67074       };
67075     } catch (...) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67078       };
67079     }
67080   }
67081   jresult = (void *)result;
67082   return jresult;
67083 }
67084
67085
67086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67087   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67088
67089   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67090   {
67091     try {
67092       delete arg1;
67093     } catch (std::out_of_range& e) {
67094       {
67095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67096       };
67097     } catch (std::exception& e) {
67098       {
67099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67100       };
67101     } catch (...) {
67102       {
67103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67104       };
67105     }
67106   }
67107 }
67108
67109
67110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67111   void * jresult ;
67112   Dali::Toolkit::ImageView *result = 0 ;
67113
67114   {
67115     try {
67116       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67117     } catch (std::out_of_range& e) {
67118       {
67119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67120       };
67121     } catch (std::exception& e) {
67122       {
67123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67124       };
67125     } catch (...) {
67126       {
67127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67128       };
67129     }
67130   }
67131   jresult = (void *)result;
67132   return jresult;
67133 }
67134
67135
67136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67137   void * jresult ;
67138   Dali::Toolkit::ImageView result;
67139
67140   {
67141     try {
67142       result = Dali::Toolkit::ImageView::New();
67143     } catch (std::out_of_range& e) {
67144       {
67145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67146       };
67147     } catch (std::exception& e) {
67148       {
67149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67150       };
67151     } catch (...) {
67152       {
67153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67154       };
67155     }
67156   }
67157   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67158   return jresult;
67159 }
67160
67161
67162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67163   void * jresult ;
67164   Dali::Image arg1 ;
67165   Dali::Image *argp1 ;
67166   Dali::Toolkit::ImageView result;
67167
67168   argp1 = (Dali::Image *)jarg1;
67169   if (!argp1) {
67170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67171     return 0;
67172   }
67173   arg1 = *argp1;
67174   {
67175     try {
67176       result = Dali::Toolkit::ImageView::New(arg1);
67177     } catch (std::out_of_range& e) {
67178       {
67179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67180       };
67181     } catch (std::exception& e) {
67182       {
67183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67184       };
67185     } catch (...) {
67186       {
67187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67188       };
67189     }
67190   }
67191   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67197   void * jresult ;
67198   std::string *arg1 = 0 ;
67199   Dali::Toolkit::ImageView result;
67200
67201   if (!jarg1) {
67202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67203     return 0;
67204   }
67205   std::string arg1_str(jarg1);
67206   arg1 = &arg1_str;
67207   {
67208     try {
67209       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67210     } catch (std::out_of_range& e) {
67211       {
67212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67213       };
67214     } catch (std::exception& e) {
67215       {
67216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67217       };
67218     } catch (...) {
67219       {
67220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67221       };
67222     }
67223   }
67224   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67225
67226   //argout typemap for const std::string&
67227
67228   return jresult;
67229 }
67230
67231
67232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67233   void * jresult ;
67234   std::string *arg1 = 0 ;
67235   Dali::ImageDimensions arg2 ;
67236   Dali::ImageDimensions *argp2 ;
67237   Dali::Toolkit::ImageView result;
67238
67239   if (!jarg1) {
67240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67241     return 0;
67242   }
67243   std::string arg1_str(jarg1);
67244   arg1 = &arg1_str;
67245   argp2 = (Dali::ImageDimensions *)jarg2;
67246   if (!argp2) {
67247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67248     return 0;
67249   }
67250   arg2 = *argp2;
67251   {
67252     try {
67253       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67254     } catch (std::out_of_range& e) {
67255       {
67256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67257       };
67258     } catch (std::exception& e) {
67259       {
67260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67261       };
67262     } catch (...) {
67263       {
67264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67265       };
67266     }
67267   }
67268   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67269
67270   //argout typemap for const std::string&
67271
67272   return jresult;
67273 }
67274
67275
67276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67277   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67278
67279   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67280   {
67281     try {
67282       delete arg1;
67283     } catch (std::out_of_range& e) {
67284       {
67285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67286       };
67287     } catch (std::exception& e) {
67288       {
67289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67290       };
67291     } catch (...) {
67292       {
67293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67294       };
67295     }
67296   }
67297 }
67298
67299
67300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67301   void * jresult ;
67302   Dali::Toolkit::ImageView *arg1 = 0 ;
67303   Dali::Toolkit::ImageView *result = 0 ;
67304
67305   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67306   if (!arg1) {
67307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67308     return 0;
67309   }
67310   {
67311     try {
67312       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67313     } catch (std::out_of_range& e) {
67314       {
67315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67316       };
67317     } catch (std::exception& e) {
67318       {
67319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67320       };
67321     } catch (...) {
67322       {
67323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67324       };
67325     }
67326   }
67327   jresult = (void *)result;
67328   return jresult;
67329 }
67330
67331
67332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67333   void * jresult ;
67334   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67335   Dali::Toolkit::ImageView *arg2 = 0 ;
67336   Dali::Toolkit::ImageView *result = 0 ;
67337
67338   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67339   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67340   if (!arg2) {
67341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67342     return 0;
67343   }
67344   {
67345     try {
67346       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67347     } catch (std::out_of_range& e) {
67348       {
67349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67350       };
67351     } catch (std::exception& e) {
67352       {
67353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67354       };
67355     } catch (...) {
67356       {
67357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67358       };
67359     }
67360   }
67361   jresult = (void *)result;
67362   return jresult;
67363 }
67364
67365
67366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67367   void * jresult ;
67368   Dali::BaseHandle arg1 ;
67369   Dali::BaseHandle *argp1 ;
67370   Dali::Toolkit::ImageView result;
67371
67372   argp1 = (Dali::BaseHandle *)jarg1;
67373   if (!argp1) {
67374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67375     return 0;
67376   }
67377   arg1 = *argp1;
67378   {
67379     try {
67380       result = Dali::Toolkit::ImageView::DownCast(arg1);
67381     } catch (std::out_of_range& e) {
67382       {
67383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67384       };
67385     } catch (std::exception& e) {
67386       {
67387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (...) {
67390       {
67391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67392       };
67393     }
67394   }
67395   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67396   return jresult;
67397 }
67398
67399
67400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67401   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67402   Dali::Image arg2 ;
67403   Dali::Image *argp2 ;
67404
67405   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67406   argp2 = (Dali::Image *)jarg2;
67407   if (!argp2) {
67408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67409     return ;
67410   }
67411   arg2 = *argp2;
67412   {
67413     try {
67414       (arg1)->SetImage(arg2);
67415     } catch (std::out_of_range& e) {
67416       {
67417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67418       };
67419     } catch (std::exception& e) {
67420       {
67421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67422       };
67423     } catch (...) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67426       };
67427     }
67428   }
67429 }
67430
67431
67432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67433   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67434   std::string *arg2 = 0 ;
67435
67436   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67437   if (!jarg2) {
67438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67439     return ;
67440   }
67441   std::string arg2_str(jarg2);
67442   arg2 = &arg2_str;
67443   {
67444     try {
67445       (arg1)->SetImage((std::string const &)*arg2);
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67457       };
67458     }
67459   }
67460
67461   //argout typemap for const std::string&
67462
67463 }
67464
67465
67466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67467   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67468   std::string *arg2 = 0 ;
67469   Dali::ImageDimensions arg3 ;
67470   Dali::ImageDimensions *argp3 ;
67471
67472   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67473   if (!jarg2) {
67474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67475     return ;
67476   }
67477   std::string arg2_str(jarg2);
67478   arg2 = &arg2_str;
67479   argp3 = (Dali::ImageDimensions *)jarg3;
67480   if (!argp3) {
67481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67482     return ;
67483   }
67484   arg3 = *argp3;
67485   {
67486     try {
67487       (arg1)->SetImage((std::string const &)*arg2,arg3);
67488     } catch (std::out_of_range& e) {
67489       {
67490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67491       };
67492     } catch (std::exception& e) {
67493       {
67494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67495       };
67496     } catch (...) {
67497       {
67498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67499       };
67500     }
67501   }
67502
67503   //argout typemap for const std::string&
67504
67505 }
67506
67507
67508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67509   void * jresult ;
67510   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67511   Dali::Image result;
67512
67513   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67514   {
67515     try {
67516       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67517     } catch (std::out_of_range& e) {
67518       {
67519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67520       };
67521     } catch (std::exception& e) {
67522       {
67523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67524       };
67525     } catch (...) {
67526       {
67527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67528       };
67529     }
67530   }
67531   jresult = new Dali::Image((const Dali::Image &)result);
67532   return jresult;
67533 }
67534
67535
67536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67537   int jresult ;
67538   int result;
67539
67540   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67541   jresult = (int)result;
67542   return jresult;
67543 }
67544
67545
67546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67547   int jresult ;
67548   int result;
67549
67550   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67551   jresult = (int)result;
67552   return jresult;
67553 }
67554
67555
67556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67557   int jresult ;
67558   int result;
67559
67560   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67561   jresult = (int)result;
67562   return jresult;
67563 }
67564
67565
67566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67567   int jresult ;
67568   int result;
67569
67570   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67571   jresult = (int)result;
67572   return jresult;
67573 }
67574
67575
67576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67577   int jresult ;
67578   int result;
67579
67580   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67581   jresult = (int)result;
67582   return jresult;
67583 }
67584
67585
67586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67587   int jresult ;
67588   int result;
67589
67590   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67591   jresult = (int)result;
67592   return jresult;
67593 }
67594
67595
67596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67597   int jresult ;
67598   int result;
67599
67600   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67601   jresult = (int)result;
67602   return jresult;
67603 }
67604
67605
67606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67607   int jresult ;
67608   int result;
67609
67610   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67611   jresult = (int)result;
67612   return jresult;
67613 }
67614
67615
67616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67617   void * jresult ;
67618   Dali::Toolkit::Model3dView::Property *result = 0 ;
67619
67620   {
67621     try {
67622       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67623     } catch (std::out_of_range& e) {
67624       {
67625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67626       };
67627     } catch (std::exception& e) {
67628       {
67629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67630       };
67631     } catch (...) {
67632       {
67633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67634       };
67635     }
67636   }
67637   jresult = (void *)result;
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67643   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67644
67645   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67646   {
67647     try {
67648       delete arg1;
67649     } catch (std::out_of_range& e) {
67650       {
67651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67652       };
67653     } catch (std::exception& e) {
67654       {
67655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67656       };
67657     } catch (...) {
67658       {
67659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67660       };
67661     }
67662   }
67663 }
67664
67665
67666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67667   void * jresult ;
67668   Dali::Toolkit::Model3dView result;
67669
67670   {
67671     try {
67672       result = Dali::Toolkit::Model3dView::New();
67673     } catch (std::out_of_range& e) {
67674       {
67675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67676       };
67677     } catch (std::exception& e) {
67678       {
67679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67680       };
67681     } catch (...) {
67682       {
67683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67684       };
67685     }
67686   }
67687   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67688   return jresult;
67689 }
67690
67691
67692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67693   void * jresult ;
67694   std::string *arg1 = 0 ;
67695   std::string *arg2 = 0 ;
67696   std::string *arg3 = 0 ;
67697   Dali::Toolkit::Model3dView result;
67698
67699   if (!jarg1) {
67700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67701     return 0;
67702   }
67703   std::string arg1_str(jarg1);
67704   arg1 = &arg1_str;
67705   if (!jarg2) {
67706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67707     return 0;
67708   }
67709   std::string arg2_str(jarg2);
67710   arg2 = &arg2_str;
67711   if (!jarg3) {
67712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67713     return 0;
67714   }
67715   std::string arg3_str(jarg3);
67716   arg3 = &arg3_str;
67717   {
67718     try {
67719       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67720     } catch (std::out_of_range& e) {
67721       {
67722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67723       };
67724     } catch (std::exception& e) {
67725       {
67726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67727       };
67728     } catch (...) {
67729       {
67730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67731       };
67732     }
67733   }
67734   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67735
67736   //argout typemap for const std::string&
67737
67738
67739   //argout typemap for const std::string&
67740
67741
67742   //argout typemap for const std::string&
67743
67744   return jresult;
67745 }
67746
67747
67748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67749   void * jresult ;
67750   Dali::Toolkit::Model3dView *result = 0 ;
67751
67752   {
67753     try {
67754       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67755     } catch (std::out_of_range& e) {
67756       {
67757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67758       };
67759     } catch (std::exception& e) {
67760       {
67761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67762       };
67763     } catch (...) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67766       };
67767     }
67768   }
67769   jresult = (void *)result;
67770   return jresult;
67771 }
67772
67773
67774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67775   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67776
67777   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67778   {
67779     try {
67780       delete arg1;
67781     } catch (std::out_of_range& e) {
67782       {
67783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67784       };
67785     } catch (std::exception& e) {
67786       {
67787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67788       };
67789     } catch (...) {
67790       {
67791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67792       };
67793     }
67794   }
67795 }
67796
67797
67798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67799   void * jresult ;
67800   Dali::Toolkit::Model3dView *arg1 = 0 ;
67801   Dali::Toolkit::Model3dView *result = 0 ;
67802
67803   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67804   if (!arg1) {
67805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67806     return 0;
67807   }
67808   {
67809     try {
67810       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67811     } catch (std::out_of_range& e) {
67812       {
67813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67814       };
67815     } catch (std::exception& e) {
67816       {
67817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67818       };
67819     } catch (...) {
67820       {
67821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67822       };
67823     }
67824   }
67825   jresult = (void *)result;
67826   return jresult;
67827 }
67828
67829
67830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67831   void * jresult ;
67832   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67833   Dali::Toolkit::Model3dView *arg2 = 0 ;
67834   Dali::Toolkit::Model3dView *result = 0 ;
67835
67836   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67837   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67838   if (!arg2) {
67839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67840     return 0;
67841   }
67842   {
67843     try {
67844       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67845     } catch (std::out_of_range& e) {
67846       {
67847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67848       };
67849     } catch (std::exception& e) {
67850       {
67851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67852       };
67853     } catch (...) {
67854       {
67855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67856       };
67857     }
67858   }
67859   jresult = (void *)result;
67860   return jresult;
67861 }
67862
67863
67864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67865   void * jresult ;
67866   Dali::BaseHandle arg1 ;
67867   Dali::BaseHandle *argp1 ;
67868   Dali::Toolkit::Model3dView result;
67869
67870   argp1 = (Dali::BaseHandle *)jarg1;
67871   if (!argp1) {
67872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67873     return 0;
67874   }
67875   arg1 = *argp1;
67876   {
67877     try {
67878       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67879     } catch (std::out_of_range& e) {
67880       {
67881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (std::exception& e) {
67884       {
67885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67886       };
67887     } catch (...) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67890       };
67891     }
67892   }
67893   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67894   return jresult;
67895 }
67896
67897
67898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67899   int jresult ;
67900   int result;
67901
67902   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67903   jresult = (int)result;
67904   return jresult;
67905 }
67906
67907
67908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67909   int jresult ;
67910   int result;
67911
67912   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67913   jresult = (int)result;
67914   return jresult;
67915 }
67916
67917
67918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67919   int jresult ;
67920   int result;
67921
67922   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67923   jresult = (int)result;
67924   return jresult;
67925 }
67926
67927
67928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67929   int jresult ;
67930   int result;
67931
67932   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67933   jresult = (int)result;
67934   return jresult;
67935 }
67936
67937
67938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67939   int jresult ;
67940   int result;
67941
67942   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67943   jresult = (int)result;
67944   return jresult;
67945 }
67946
67947
67948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67949   int jresult ;
67950   int result;
67951
67952   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67953   jresult = (int)result;
67954   return jresult;
67955 }
67956
67957
67958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67959   int jresult ;
67960   int result;
67961
67962   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67963   jresult = (int)result;
67964   return jresult;
67965 }
67966
67967
67968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67969   int jresult ;
67970   int result;
67971
67972   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67973   jresult = (int)result;
67974   return jresult;
67975 }
67976
67977
67978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67979   int jresult ;
67980   int result;
67981
67982   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67983   jresult = (int)result;
67984   return jresult;
67985 }
67986
67987
67988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67989   void * jresult ;
67990   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67991
67992   {
67993     try {
67994       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67995     } catch (std::out_of_range& e) {
67996       {
67997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67998       };
67999     } catch (std::exception& e) {
68000       {
68001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68002       };
68003     } catch (...) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68006       };
68007     }
68008   }
68009   jresult = (void *)result;
68010   return jresult;
68011 }
68012
68013
68014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68015   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68016
68017   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68018   {
68019     try {
68020       delete arg1;
68021     } catch (std::out_of_range& e) {
68022       {
68023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68024       };
68025     } catch (std::exception& e) {
68026       {
68027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68028       };
68029     } catch (...) {
68030       {
68031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68032       };
68033     }
68034   }
68035 }
68036
68037
68038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68039   void * jresult ;
68040   Dali::Toolkit::ScrollBar *result = 0 ;
68041
68042   {
68043     try {
68044       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68045     } catch (std::out_of_range& e) {
68046       {
68047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (std::exception& e) {
68050       {
68051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68052       };
68053     } catch (...) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68056       };
68057     }
68058   }
68059   jresult = (void *)result;
68060   return jresult;
68061 }
68062
68063
68064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68065   void * jresult ;
68066   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68067   Dali::Toolkit::ScrollBar *result = 0 ;
68068
68069   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68070   if (!arg1) {
68071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68072     return 0;
68073   }
68074   {
68075     try {
68076       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68077     } catch (std::out_of_range& e) {
68078       {
68079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68080       };
68081     } catch (std::exception& e) {
68082       {
68083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68084       };
68085     } catch (...) {
68086       {
68087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68088       };
68089     }
68090   }
68091   jresult = (void *)result;
68092   return jresult;
68093 }
68094
68095
68096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68097   void * jresult ;
68098   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68099   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68100   Dali::Toolkit::ScrollBar *result = 0 ;
68101
68102   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68103   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68104   if (!arg2) {
68105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68106     return 0;
68107   }
68108   {
68109     try {
68110       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (...) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68122       };
68123     }
68124   }
68125   jresult = (void *)result;
68126   return jresult;
68127 }
68128
68129
68130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68131   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68132
68133   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68134   {
68135     try {
68136       delete arg1;
68137     } catch (std::out_of_range& e) {
68138       {
68139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68140       };
68141     } catch (std::exception& e) {
68142       {
68143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68144       };
68145     } catch (...) {
68146       {
68147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68148       };
68149     }
68150   }
68151 }
68152
68153
68154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68155   void * jresult ;
68156   Dali::Toolkit::ScrollBar::Direction arg1 ;
68157   Dali::Toolkit::ScrollBar result;
68158
68159   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68160   {
68161     try {
68162       result = Dali::Toolkit::ScrollBar::New(arg1);
68163     } catch (std::out_of_range& e) {
68164       {
68165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68166       };
68167     } catch (std::exception& e) {
68168       {
68169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68170       };
68171     } catch (...) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68174       };
68175     }
68176   }
68177   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68178   return jresult;
68179 }
68180
68181
68182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68183   void * jresult ;
68184   Dali::Toolkit::ScrollBar result;
68185
68186   {
68187     try {
68188       result = Dali::Toolkit::ScrollBar::New();
68189     } catch (std::out_of_range& e) {
68190       {
68191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68192       };
68193     } catch (std::exception& e) {
68194       {
68195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68196       };
68197     } catch (...) {
68198       {
68199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68200       };
68201     }
68202   }
68203   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68209   void * jresult ;
68210   Dali::BaseHandle arg1 ;
68211   Dali::BaseHandle *argp1 ;
68212   Dali::Toolkit::ScrollBar result;
68213
68214   argp1 = (Dali::BaseHandle *)jarg1;
68215   if (!argp1) {
68216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68217     return 0;
68218   }
68219   arg1 = *argp1;
68220   {
68221     try {
68222       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68223     } catch (std::out_of_range& e) {
68224       {
68225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68226       };
68227     } catch (std::exception& e) {
68228       {
68229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68230       };
68231     } catch (...) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68234       };
68235     }
68236   }
68237   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68238   return jresult;
68239 }
68240
68241
68242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68243   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68244   Dali::Handle arg2 ;
68245   Dali::Property::Index arg3 ;
68246   Dali::Property::Index arg4 ;
68247   Dali::Property::Index arg5 ;
68248   Dali::Property::Index arg6 ;
68249   Dali::Handle *argp2 ;
68250
68251   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68252   argp2 = (Dali::Handle *)jarg2;
68253   if (!argp2) {
68254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68255     return ;
68256   }
68257   arg2 = *argp2;
68258   arg3 = (Dali::Property::Index)jarg3;
68259   arg4 = (Dali::Property::Index)jarg4;
68260   arg5 = (Dali::Property::Index)jarg5;
68261   arg6 = (Dali::Property::Index)jarg6;
68262   {
68263     try {
68264       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68265     } catch (std::out_of_range& e) {
68266       {
68267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68268       };
68269     } catch (std::exception& e) {
68270       {
68271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68272       };
68273     } catch (...) {
68274       {
68275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68276       };
68277     }
68278   }
68279 }
68280
68281
68282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68283   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68284   Dali::Actor arg2 ;
68285   Dali::Actor *argp2 ;
68286
68287   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68288   argp2 = (Dali::Actor *)jarg2;
68289   if (!argp2) {
68290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68291     return ;
68292   }
68293   arg2 = *argp2;
68294   {
68295     try {
68296       (arg1)->SetScrollIndicator(arg2);
68297     } catch (std::out_of_range& e) {
68298       {
68299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68300       };
68301     } catch (std::exception& e) {
68302       {
68303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68304       };
68305     } catch (...) {
68306       {
68307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68308       };
68309     }
68310   }
68311 }
68312
68313
68314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68315   void * jresult ;
68316   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68317   Dali::Actor result;
68318
68319   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68320   {
68321     try {
68322       result = (arg1)->GetScrollIndicator();
68323     } catch (std::out_of_range& e) {
68324       {
68325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68326       };
68327     } catch (std::exception& e) {
68328       {
68329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (...) {
68332       {
68333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68334       };
68335     }
68336   }
68337   jresult = new Dali::Actor((const Dali::Actor &)result);
68338   return jresult;
68339 }
68340
68341
68342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68343   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68344   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68345
68346   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68347   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68348   if (!arg2) {
68349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68350     return ;
68351   }
68352   {
68353     try {
68354       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68366       };
68367     }
68368   }
68369 }
68370
68371
68372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68373   void * jresult ;
68374   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68375   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68376
68377   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68378   {
68379     try {
68380       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68381     } catch (std::out_of_range& e) {
68382       {
68383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68384       };
68385     } catch (std::exception& e) {
68386       {
68387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68388       };
68389     } catch (...) {
68390       {
68391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68392       };
68393     }
68394   }
68395   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68396   return jresult;
68397 }
68398
68399
68400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68401   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68402   Dali::Toolkit::ScrollBar::Direction arg2 ;
68403
68404   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68405   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68406   {
68407     try {
68408       (arg1)->SetScrollDirection(arg2);
68409     } catch (std::out_of_range& e) {
68410       {
68411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68412       };
68413     } catch (std::exception& e) {
68414       {
68415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68416       };
68417     } catch (...) {
68418       {
68419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68420       };
68421     }
68422   }
68423 }
68424
68425
68426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68427   int jresult ;
68428   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68429   Dali::Toolkit::ScrollBar::Direction result;
68430
68431   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68432   {
68433     try {
68434       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68435     } catch (std::out_of_range& e) {
68436       {
68437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68438       };
68439     } catch (std::exception& e) {
68440       {
68441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68442       };
68443     } catch (...) {
68444       {
68445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68446       };
68447     }
68448   }
68449   jresult = (int)result;
68450   return jresult;
68451 }
68452
68453
68454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68455   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68456   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68457
68458   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68459   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68460   {
68461     try {
68462       (arg1)->SetIndicatorHeightPolicy(arg2);
68463     } catch (std::out_of_range& e) {
68464       {
68465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68466       };
68467     } catch (std::exception& e) {
68468       {
68469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68470       };
68471     } catch (...) {
68472       {
68473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68474       };
68475     }
68476   }
68477 }
68478
68479
68480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68481   int jresult ;
68482   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68483   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68484
68485   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68486   {
68487     try {
68488       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68489     } catch (std::out_of_range& e) {
68490       {
68491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68492       };
68493     } catch (std::exception& e) {
68494       {
68495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68496       };
68497     } catch (...) {
68498       {
68499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68500       };
68501     }
68502   }
68503   jresult = (int)result;
68504   return jresult;
68505 }
68506
68507
68508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68509   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68510   float arg2 ;
68511
68512   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68513   arg2 = (float)jarg2;
68514   {
68515     try {
68516       (arg1)->SetIndicatorFixedHeight(arg2);
68517     } catch (std::out_of_range& e) {
68518       {
68519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68520       };
68521     } catch (std::exception& e) {
68522       {
68523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68524       };
68525     } catch (...) {
68526       {
68527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68528       };
68529     }
68530   }
68531 }
68532
68533
68534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68535   float jresult ;
68536   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68537   float result;
68538
68539   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68540   {
68541     try {
68542       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68543     } catch (std::out_of_range& e) {
68544       {
68545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68546       };
68547     } catch (std::exception& e) {
68548       {
68549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68550       };
68551     } catch (...) {
68552       {
68553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68554       };
68555     }
68556   }
68557   jresult = result;
68558   return jresult;
68559 }
68560
68561
68562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68563   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68564   float arg2 ;
68565
68566   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68567   arg2 = (float)jarg2;
68568   {
68569     try {
68570       (arg1)->SetIndicatorShowDuration(arg2);
68571     } catch (std::out_of_range& e) {
68572       {
68573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68574       };
68575     } catch (std::exception& e) {
68576       {
68577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68578       };
68579     } catch (...) {
68580       {
68581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68582       };
68583     }
68584   }
68585 }
68586
68587
68588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68589   float jresult ;
68590   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68591   float result;
68592
68593   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68594   {
68595     try {
68596       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68597     } catch (std::out_of_range& e) {
68598       {
68599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68600       };
68601     } catch (std::exception& e) {
68602       {
68603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68604       };
68605     } catch (...) {
68606       {
68607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68608       };
68609     }
68610   }
68611   jresult = result;
68612   return jresult;
68613 }
68614
68615
68616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68617   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68618   float arg2 ;
68619
68620   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68621   arg2 = (float)jarg2;
68622   {
68623     try {
68624       (arg1)->SetIndicatorHideDuration(arg2);
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68632       };
68633     } catch (...) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68636       };
68637     }
68638   }
68639 }
68640
68641
68642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68643   float jresult ;
68644   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68645   float result;
68646
68647   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68648   {
68649     try {
68650       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68651     } catch (std::out_of_range& e) {
68652       {
68653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68654       };
68655     } catch (std::exception& e) {
68656       {
68657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68658       };
68659     } catch (...) {
68660       {
68661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68662       };
68663     }
68664   }
68665   jresult = result;
68666   return jresult;
68667 }
68668
68669
68670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68672
68673   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68674   {
68675     try {
68676       (arg1)->ShowIndicator();
68677     } catch (std::out_of_range& e) {
68678       {
68679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68680       };
68681     } catch (std::exception& e) {
68682       {
68683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68684       };
68685     } catch (...) {
68686       {
68687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68688       };
68689     }
68690   }
68691 }
68692
68693
68694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68695   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68696
68697   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68698   {
68699     try {
68700       (arg1)->HideIndicator();
68701     } catch (std::out_of_range& e) {
68702       {
68703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68704       };
68705     } catch (std::exception& e) {
68706       {
68707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68708       };
68709     } catch (...) {
68710       {
68711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68712       };
68713     }
68714   }
68715 }
68716
68717
68718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68719   void * jresult ;
68720   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68721   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68722
68723   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68724   {
68725     try {
68726       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68727     } catch (std::out_of_range& e) {
68728       {
68729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68730       };
68731     } catch (std::exception& e) {
68732       {
68733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68734       };
68735     } catch (...) {
68736       {
68737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68738       };
68739     }
68740   }
68741   jresult = (void *)result;
68742   return jresult;
68743 }
68744
68745
68746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68747   void * jresult ;
68748   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68749   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68750
68751   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68752   {
68753     try {
68754       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68755     } catch (std::out_of_range& e) {
68756       {
68757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68758       };
68759     } catch (std::exception& e) {
68760       {
68761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68762       };
68763     } catch (...) {
68764       {
68765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68766       };
68767     }
68768   }
68769   jresult = (void *)result;
68770   return jresult;
68771 }
68772
68773
68774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68775   int jresult ;
68776   int result;
68777
68778   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68779   jresult = (int)result;
68780   return jresult;
68781 }
68782
68783
68784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68785   int jresult ;
68786   int result;
68787
68788   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68789   jresult = (int)result;
68790   return jresult;
68791 }
68792
68793
68794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68795   int jresult ;
68796   int result;
68797
68798   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68799   jresult = (int)result;
68800   return jresult;
68801 }
68802
68803
68804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68805   int jresult ;
68806   int result;
68807
68808   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68809   jresult = (int)result;
68810   return jresult;
68811 }
68812
68813
68814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68815   int jresult ;
68816   int result;
68817
68818   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68819   jresult = (int)result;
68820   return jresult;
68821 }
68822
68823
68824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68825   int jresult ;
68826   int result;
68827
68828   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68829   jresult = (int)result;
68830   return jresult;
68831 }
68832
68833
68834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68835   int jresult ;
68836   int result;
68837
68838   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68839   jresult = (int)result;
68840   return jresult;
68841 }
68842
68843
68844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68845   int jresult ;
68846   int result;
68847
68848   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68849   jresult = (int)result;
68850   return jresult;
68851 }
68852
68853
68854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68855   int jresult ;
68856   int result;
68857
68858   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68859   jresult = (int)result;
68860   return jresult;
68861 }
68862
68863
68864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68865   int jresult ;
68866   int result;
68867
68868   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68869   jresult = (int)result;
68870   return jresult;
68871 }
68872
68873
68874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68875   int jresult ;
68876   int result;
68877
68878   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68879   jresult = (int)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68885   int jresult ;
68886   int result;
68887
68888   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68889   jresult = (int)result;
68890   return jresult;
68891 }
68892
68893
68894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68895   int jresult ;
68896   int result;
68897
68898   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68899   jresult = (int)result;
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68905   int jresult ;
68906   int result;
68907
68908   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68909   jresult = (int)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68915   void * jresult ;
68916   Dali::Toolkit::Scrollable::Property *result = 0 ;
68917
68918   {
68919     try {
68920       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68921     } catch (std::out_of_range& e) {
68922       {
68923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68924       };
68925     } catch (std::exception& e) {
68926       {
68927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68928       };
68929     } catch (...) {
68930       {
68931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68932       };
68933     }
68934   }
68935   jresult = (void *)result;
68936   return jresult;
68937 }
68938
68939
68940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68941   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68942
68943   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68944   {
68945     try {
68946       delete arg1;
68947     } catch (std::out_of_range& e) {
68948       {
68949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68950       };
68951     } catch (std::exception& e) {
68952       {
68953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68954       };
68955     } catch (...) {
68956       {
68957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68958       };
68959     }
68960   }
68961 }
68962
68963
68964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68965   void * jresult ;
68966   Dali::Toolkit::Scrollable *result = 0 ;
68967
68968   {
68969     try {
68970       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68971     } catch (std::out_of_range& e) {
68972       {
68973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68974       };
68975     } catch (std::exception& e) {
68976       {
68977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68978       };
68979     } catch (...) {
68980       {
68981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68982       };
68983     }
68984   }
68985   jresult = (void *)result;
68986   return jresult;
68987 }
68988
68989
68990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68991   void * jresult ;
68992   Dali::Toolkit::Scrollable *arg1 = 0 ;
68993   Dali::Toolkit::Scrollable *result = 0 ;
68994
68995   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68996   if (!arg1) {
68997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68998     return 0;
68999   }
69000   {
69001     try {
69002       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69003     } catch (std::out_of_range& e) {
69004       {
69005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69006       };
69007     } catch (std::exception& e) {
69008       {
69009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69010       };
69011     } catch (...) {
69012       {
69013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69014       };
69015     }
69016   }
69017   jresult = (void *)result;
69018   return jresult;
69019 }
69020
69021
69022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69023   void * jresult ;
69024   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69025   Dali::Toolkit::Scrollable *arg2 = 0 ;
69026   Dali::Toolkit::Scrollable *result = 0 ;
69027
69028   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69029   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69030   if (!arg2) {
69031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69032     return 0;
69033   }
69034   {
69035     try {
69036       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69037     } catch (std::out_of_range& e) {
69038       {
69039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69040       };
69041     } catch (std::exception& e) {
69042       {
69043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69044       };
69045     } catch (...) {
69046       {
69047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69048       };
69049     }
69050   }
69051   jresult = (void *)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69057   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69058
69059   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69060   {
69061     try {
69062       delete arg1;
69063     } catch (std::out_of_range& e) {
69064       {
69065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69066       };
69067     } catch (std::exception& e) {
69068       {
69069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69070       };
69071     } catch (...) {
69072       {
69073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69074       };
69075     }
69076   }
69077 }
69078
69079
69080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69081   void * jresult ;
69082   Dali::BaseHandle arg1 ;
69083   Dali::BaseHandle *argp1 ;
69084   Dali::Toolkit::Scrollable result;
69085
69086   argp1 = (Dali::BaseHandle *)jarg1;
69087   if (!argp1) {
69088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69089     return 0;
69090   }
69091   arg1 = *argp1;
69092   {
69093     try {
69094       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69095     } catch (std::out_of_range& e) {
69096       {
69097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (std::exception& e) {
69100       {
69101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69102       };
69103     } catch (...) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69106       };
69107     }
69108   }
69109   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69110   return jresult;
69111 }
69112
69113
69114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69115   unsigned int jresult ;
69116   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69117   bool result;
69118
69119   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69120   {
69121     try {
69122       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69123     } catch (std::out_of_range& e) {
69124       {
69125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69126       };
69127     } catch (std::exception& e) {
69128       {
69129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69130       };
69131     } catch (...) {
69132       {
69133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69134       };
69135     }
69136   }
69137   jresult = result;
69138   return jresult;
69139 }
69140
69141
69142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69143   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69144   bool arg2 ;
69145
69146   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69147   arg2 = jarg2 ? true : false;
69148   {
69149     try {
69150       (arg1)->SetOvershootEnabled(arg2);
69151     } catch (std::out_of_range& e) {
69152       {
69153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69154       };
69155     } catch (std::exception& e) {
69156       {
69157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69158       };
69159     } catch (...) {
69160       {
69161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69162       };
69163     }
69164   }
69165 }
69166
69167
69168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69169   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69170   Dali::Vector4 *arg2 = 0 ;
69171
69172   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69173   arg2 = (Dali::Vector4 *)jarg2;
69174   if (!arg2) {
69175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69176     return ;
69177   }
69178   {
69179     try {
69180       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69192       };
69193     }
69194   }
69195 }
69196
69197
69198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69199   void * jresult ;
69200   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69201   Dali::Vector4 result;
69202
69203   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69204   {
69205     try {
69206       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69218       };
69219     }
69220   }
69221   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69222   return jresult;
69223 }
69224
69225
69226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69227   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69228   float arg2 ;
69229
69230   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69231   arg2 = (float)jarg2;
69232   {
69233     try {
69234       (arg1)->SetOvershootAnimationSpeed(arg2);
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69242       };
69243     } catch (...) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69246       };
69247     }
69248   }
69249 }
69250
69251
69252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69253   float jresult ;
69254   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69255   float result;
69256
69257   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69258   {
69259     try {
69260       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69261     } catch (std::out_of_range& e) {
69262       {
69263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69264       };
69265     } catch (std::exception& e) {
69266       {
69267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69268       };
69269     } catch (...) {
69270       {
69271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69272       };
69273     }
69274   }
69275   jresult = result;
69276   return jresult;
69277 }
69278
69279
69280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69281   void * jresult ;
69282   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69283   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69284
69285   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69286   {
69287     try {
69288       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69289     } catch (std::out_of_range& e) {
69290       {
69291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69292       };
69293     } catch (std::exception& e) {
69294       {
69295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69296       };
69297     } catch (...) {
69298       {
69299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69300       };
69301     }
69302   }
69303   jresult = (void *)result;
69304   return jresult;
69305 }
69306
69307
69308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69309   void * jresult ;
69310   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69311   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69312
69313   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69314   {
69315     try {
69316       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69317     } catch (std::out_of_range& e) {
69318       {
69319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69320       };
69321     } catch (std::exception& e) {
69322       {
69323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69324       };
69325     } catch (...) {
69326       {
69327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69328       };
69329     }
69330   }
69331   jresult = (void *)result;
69332   return jresult;
69333 }
69334
69335
69336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69337   void * jresult ;
69338   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69339   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69340
69341   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69342   {
69343     try {
69344       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69345     } catch (std::out_of_range& e) {
69346       {
69347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69348       };
69349     } catch (std::exception& e) {
69350       {
69351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69352       };
69353     } catch (...) {
69354       {
69355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69356       };
69357     }
69358   }
69359   jresult = (void *)result;
69360   return jresult;
69361 }
69362
69363
69364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69365   unsigned int jresult ;
69366   Dali::Toolkit::ControlOrientation::Type arg1 ;
69367   bool result;
69368
69369   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69370   {
69371     try {
69372       result = (bool)Dali::Toolkit::IsVertical(arg1);
69373     } catch (std::out_of_range& e) {
69374       {
69375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69376       };
69377     } catch (std::exception& e) {
69378       {
69379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (...) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69384       };
69385     }
69386   }
69387   jresult = result;
69388   return jresult;
69389 }
69390
69391
69392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69393   unsigned int jresult ;
69394   Dali::Toolkit::ControlOrientation::Type arg1 ;
69395   bool result;
69396
69397   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69398   {
69399     try {
69400       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69401     } catch (std::out_of_range& e) {
69402       {
69403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69404       };
69405     } catch (std::exception& e) {
69406       {
69407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (...) {
69410       {
69411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69412       };
69413     }
69414   }
69415   jresult = result;
69416   return jresult;
69417 }
69418
69419
69420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69421   void * jresult ;
69422   unsigned int arg1 ;
69423   unsigned int arg2 ;
69424   Dali::Toolkit::ItemRange *result = 0 ;
69425
69426   arg1 = (unsigned int)jarg1;
69427   arg2 = (unsigned int)jarg2;
69428   {
69429     try {
69430       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69431     } catch (std::out_of_range& e) {
69432       {
69433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69434       };
69435     } catch (std::exception& e) {
69436       {
69437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69438       };
69439     } catch (...) {
69440       {
69441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69442       };
69443     }
69444   }
69445   jresult = (void *)result;
69446   return jresult;
69447 }
69448
69449
69450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69451   void * jresult ;
69452   Dali::Toolkit::ItemRange *arg1 = 0 ;
69453   Dali::Toolkit::ItemRange *result = 0 ;
69454
69455   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69456   if (!arg1) {
69457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69458     return 0;
69459   }
69460   {
69461     try {
69462       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69463     } catch (std::out_of_range& e) {
69464       {
69465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69466       };
69467     } catch (std::exception& e) {
69468       {
69469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69470       };
69471     } catch (...) {
69472       {
69473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69474       };
69475     }
69476   }
69477   jresult = (void *)result;
69478   return jresult;
69479 }
69480
69481
69482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69483   void * jresult ;
69484   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69485   Dali::Toolkit::ItemRange *arg2 = 0 ;
69486   Dali::Toolkit::ItemRange *result = 0 ;
69487
69488   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69489   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69490   if (!arg2) {
69491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69492     return 0;
69493   }
69494   {
69495     try {
69496       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69497     } catch (std::out_of_range& e) {
69498       {
69499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69500       };
69501     } catch (std::exception& e) {
69502       {
69503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69504       };
69505     } catch (...) {
69506       {
69507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69508       };
69509     }
69510   }
69511   jresult = (void *)result;
69512   return jresult;
69513 }
69514
69515
69516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69517   unsigned int jresult ;
69518   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69519   unsigned int arg2 ;
69520   bool result;
69521
69522   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69523   arg2 = (unsigned int)jarg2;
69524   {
69525     try {
69526       result = (bool)(arg1)->Within(arg2);
69527     } catch (std::out_of_range& e) {
69528       {
69529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69530       };
69531     } catch (std::exception& e) {
69532       {
69533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (...) {
69536       {
69537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69538       };
69539     }
69540   }
69541   jresult = result;
69542   return jresult;
69543 }
69544
69545
69546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69547   void * jresult ;
69548   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69549   Dali::Toolkit::ItemRange *arg2 = 0 ;
69550   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69551
69552   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69553   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69554   if (!arg2) {
69555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69556     return 0;
69557   }
69558   {
69559     try {
69560       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69561     } catch (std::out_of_range& e) {
69562       {
69563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69564       };
69565     } catch (std::exception& e) {
69566       {
69567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (...) {
69570       {
69571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69572       };
69573     }
69574   }
69575   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69576   return jresult;
69577 }
69578
69579
69580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69581   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69582   unsigned int arg2 ;
69583
69584   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69585   arg2 = (unsigned int)jarg2;
69586   if (arg1) (arg1)->begin = arg2;
69587 }
69588
69589
69590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69591   unsigned int jresult ;
69592   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69593   unsigned int result;
69594
69595   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69596   result = (unsigned int) ((arg1)->begin);
69597   jresult = result;
69598   return jresult;
69599 }
69600
69601
69602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69603   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69604   unsigned int arg2 ;
69605
69606   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69607   arg2 = (unsigned int)jarg2;
69608   if (arg1) (arg1)->end = arg2;
69609 }
69610
69611
69612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69613   unsigned int jresult ;
69614   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69615   unsigned int result;
69616
69617   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69618   result = (unsigned int) ((arg1)->end);
69619   jresult = result;
69620   return jresult;
69621 }
69622
69623
69624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69625   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69626
69627   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69628   {
69629     try {
69630       delete arg1;
69631     } catch (std::out_of_range& e) {
69632       {
69633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69634       };
69635     } catch (std::exception& e) {
69636       {
69637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69638       };
69639     } catch (...) {
69640       {
69641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69642       };
69643     }
69644   }
69645 }
69646
69647
69648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69650
69651   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69652   {
69653     try {
69654       delete arg1;
69655     } catch (std::out_of_range& e) {
69656       {
69657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69658       };
69659     } catch (std::exception& e) {
69660       {
69661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69662       };
69663     } catch (...) {
69664       {
69665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69666       };
69667     }
69668   }
69669 }
69670
69671
69672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69673   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69674   Dali::Toolkit::ControlOrientation::Type arg2 ;
69675
69676   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69677   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69678   {
69679     try {
69680       (arg1)->SetOrientation(arg2);
69681     } catch (std::out_of_range& e) {
69682       {
69683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69684       };
69685     } catch (std::exception& e) {
69686       {
69687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69688       };
69689     } catch (...) {
69690       {
69691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69692       };
69693     }
69694   }
69695 }
69696
69697
69698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69699   int jresult ;
69700   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69701   Dali::Toolkit::ControlOrientation::Type result;
69702
69703   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69704   {
69705     try {
69706       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69707     } catch (std::out_of_range& e) {
69708       {
69709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (std::exception& e) {
69712       {
69713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69718       };
69719     }
69720   }
69721   jresult = (int)result;
69722   return jresult;
69723 }
69724
69725
69726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69727   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69728   Dali::Property::Map *arg2 = 0 ;
69729
69730   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69731   arg2 = (Dali::Property::Map *)jarg2;
69732   if (!arg2) {
69733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69734     return ;
69735   }
69736   {
69737     try {
69738       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69739     } catch (std::out_of_range& e) {
69740       {
69741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69742       };
69743     } catch (std::exception& e) {
69744       {
69745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69750       };
69751     }
69752   }
69753 }
69754
69755
69756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69757   void * jresult ;
69758   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69759   Dali::Property::Map result;
69760
69761   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69762   {
69763     try {
69764       result = (arg1)->GetLayoutProperties();
69765     } catch (std::out_of_range& e) {
69766       {
69767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69768       };
69769     } catch (std::exception& e) {
69770       {
69771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (...) {
69774       {
69775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69776       };
69777     }
69778   }
69779   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69780   return jresult;
69781 }
69782
69783
69784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69785   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69786   unsigned int arg2 ;
69787   Dali::Vector3 *arg3 = 0 ;
69788   Dali::Vector3 *arg4 = 0 ;
69789
69790   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69791   arg2 = (unsigned int)jarg2;
69792   arg3 = (Dali::Vector3 *)jarg3;
69793   if (!arg3) {
69794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69795     return ;
69796   }
69797   arg4 = (Dali::Vector3 *)jarg4;
69798   if (!arg4) {
69799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69800     return ;
69801   }
69802   {
69803     try {
69804       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69805     } catch (std::out_of_range& e) {
69806       {
69807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69808       };
69809     } catch (std::exception& e) {
69810       {
69811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69816       };
69817     }
69818   }
69819 }
69820
69821
69822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69823   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69824   Dali::Vector3 *arg2 = 0 ;
69825
69826   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69827   arg2 = (Dali::Vector3 *)jarg2;
69828   if (!arg2) {
69829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69830     return ;
69831   }
69832   {
69833     try {
69834       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69846       };
69847     }
69848   }
69849 }
69850
69851
69852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69853   float jresult ;
69854   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69855   unsigned int arg2 ;
69856   Dali::Vector3 arg3 ;
69857   Dali::Vector3 *argp3 ;
69858   float result;
69859
69860   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69861   arg2 = (unsigned int)jarg2;
69862   argp3 = (Dali::Vector3 *)jarg3;
69863   if (!argp3) {
69864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69865     return 0;
69866   }
69867   arg3 = *argp3;
69868   {
69869     try {
69870       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69871     } catch (std::out_of_range& e) {
69872       {
69873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69874       };
69875     } catch (std::exception& e) {
69876       {
69877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (...) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69882       };
69883     }
69884   }
69885   jresult = result;
69886   return jresult;
69887 }
69888
69889
69890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69891   float jresult ;
69892   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69893   float arg2 ;
69894   float result;
69895
69896   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69897   arg2 = (float)jarg2;
69898   {
69899     try {
69900       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (...) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69912       };
69913     }
69914   }
69915   jresult = result;
69916   return jresult;
69917 }
69918
69919
69920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69921   float jresult ;
69922   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69923   unsigned int arg2 ;
69924   float result;
69925
69926   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69927   arg2 = (unsigned int)jarg2;
69928   {
69929     try {
69930       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69931     } catch (std::out_of_range& e) {
69932       {
69933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (std::exception& e) {
69936       {
69937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69938       };
69939     } catch (...) {
69940       {
69941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69942       };
69943     }
69944   }
69945   jresult = result;
69946   return jresult;
69947 }
69948
69949
69950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69951   void * jresult ;
69952   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69953   float arg2 ;
69954   Dali::Vector3 arg3 ;
69955   Dali::Vector3 *argp3 ;
69956   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69957
69958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69959   arg2 = (float)jarg2;
69960   argp3 = (Dali::Vector3 *)jarg3;
69961   if (!argp3) {
69962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69963     return 0;
69964   }
69965   arg3 = *argp3;
69966   {
69967     try {
69968       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69969     } catch (std::out_of_range& e) {
69970       {
69971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69972       };
69973     } catch (std::exception& e) {
69974       {
69975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69976       };
69977     } catch (...) {
69978       {
69979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69980       };
69981     }
69982   }
69983   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69984   return jresult;
69985 }
69986
69987
69988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69989   float jresult ;
69990   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69991   int arg2 ;
69992   float arg3 ;
69993   Dali::Vector3 *arg4 = 0 ;
69994   float result;
69995
69996   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69997   arg2 = (int)jarg2;
69998   arg3 = (float)jarg3;
69999   arg4 = (Dali::Vector3 *)jarg4;
70000   if (!arg4) {
70001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70002     return 0;
70003   }
70004   {
70005     try {
70006       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70007     } catch (std::out_of_range& e) {
70008       {
70009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70010       };
70011     } catch (std::exception& e) {
70012       {
70013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (...) {
70016       {
70017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70018       };
70019     }
70020   }
70021   jresult = result;
70022   return jresult;
70023 }
70024
70025
70026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70027   unsigned int jresult ;
70028   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70029   Dali::Vector3 arg2 ;
70030   Dali::Vector3 *argp2 ;
70031   unsigned int result;
70032
70033   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70034   argp2 = (Dali::Vector3 *)jarg2;
70035   if (!argp2) {
70036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70037     return 0;
70038   }
70039   arg2 = *argp2;
70040   {
70041     try {
70042       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70043     } catch (std::out_of_range& e) {
70044       {
70045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70046       };
70047     } catch (std::exception& e) {
70048       {
70049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70050       };
70051     } catch (...) {
70052       {
70053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70054       };
70055     }
70056   }
70057   jresult = result;
70058   return jresult;
70059 }
70060
70061
70062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70063   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70064   unsigned int arg2 ;
70065   Dali::Vector3 *arg3 = 0 ;
70066   Dali::Vector3 *arg4 = 0 ;
70067
70068   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70069   arg2 = (unsigned int)jarg2;
70070   arg3 = (Dali::Vector3 *)jarg3;
70071   if (!arg3) {
70072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70073     return ;
70074   }
70075   arg4 = (Dali::Vector3 *)jarg4;
70076   if (!arg4) {
70077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70078     return ;
70079   }
70080   {
70081     try {
70082       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70083     } catch (std::out_of_range& e) {
70084       {
70085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70086       };
70087     } catch (std::exception& e) {
70088       {
70089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70090       };
70091     } catch (...) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70094       };
70095     }
70096   }
70097 }
70098
70099
70100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70101   void * jresult ;
70102   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70103   Dali::Degree result;
70104
70105   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70106   {
70107     try {
70108       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70109     } catch (std::out_of_range& e) {
70110       {
70111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (std::exception& e) {
70114       {
70115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70120       };
70121     }
70122   }
70123   jresult = new Dali::Degree((const Dali::Degree &)result);
70124   return jresult;
70125 }
70126
70127
70128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70129   float jresult ;
70130   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70131   float result;
70132
70133   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70134   {
70135     try {
70136       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70137     } catch (std::out_of_range& e) {
70138       {
70139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70140       };
70141     } catch (std::exception& e) {
70142       {
70143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70144       };
70145     } catch (...) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70148       };
70149     }
70150   }
70151   jresult = result;
70152   return jresult;
70153 }
70154
70155
70156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70157   float jresult ;
70158   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70159   float result;
70160
70161   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70162   {
70163     try {
70164       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70165     } catch (std::out_of_range& e) {
70166       {
70167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70168       };
70169     } catch (std::exception& e) {
70170       {
70171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70172       };
70173     } catch (...) {
70174       {
70175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70176       };
70177     }
70178   }
70179   jresult = result;
70180   return jresult;
70181 }
70182
70183
70184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70185   float jresult ;
70186   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70187   float result;
70188
70189   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70190   {
70191     try {
70192       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70193     } catch (std::out_of_range& e) {
70194       {
70195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (std::exception& e) {
70198       {
70199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70200       };
70201     } catch (...) {
70202       {
70203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70204       };
70205     }
70206   }
70207   jresult = result;
70208   return jresult;
70209 }
70210
70211
70212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70213   int jresult ;
70214   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70215   int arg2 ;
70216   int arg3 ;
70217   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70218   bool arg5 ;
70219   int result;
70220
70221   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70222   arg2 = (int)jarg2;
70223   arg3 = (int)jarg3;
70224   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70225   arg5 = jarg5 ? true : false;
70226   {
70227     try {
70228       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70229     } catch (std::out_of_range& e) {
70230       {
70231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70232       };
70233     } catch (std::exception& e) {
70234       {
70235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70236       };
70237     } catch (...) {
70238       {
70239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70240       };
70241     }
70242   }
70243   jresult = result;
70244   return jresult;
70245 }
70246
70247
70248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70249   float jresult ;
70250   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70251   float result;
70252
70253   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70254   {
70255     try {
70256       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70257     } catch (std::out_of_range& e) {
70258       {
70259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70260       };
70261     } catch (std::exception& e) {
70262       {
70263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70264       };
70265     } catch (...) {
70266       {
70267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70268       };
70269     }
70270   }
70271   jresult = result;
70272   return jresult;
70273 }
70274
70275
70276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70277   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70278   Dali::Actor *arg2 = 0 ;
70279   int arg3 ;
70280   Dali::Vector3 *arg4 = 0 ;
70281   Dali::Actor *arg5 = 0 ;
70282
70283   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70284   arg2 = (Dali::Actor *)jarg2;
70285   if (!arg2) {
70286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70287     return ;
70288   }
70289   arg3 = (int)jarg3;
70290   arg4 = (Dali::Vector3 *)jarg4;
70291   if (!arg4) {
70292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70293     return ;
70294   }
70295   arg5 = (Dali::Actor *)jarg5;
70296   if (!arg5) {
70297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70298     return ;
70299   }
70300   {
70301     try {
70302       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70303     } catch (std::out_of_range& e) {
70304       {
70305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70306       };
70307     } catch (std::exception& e) {
70308       {
70309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70310       };
70311     } catch (...) {
70312       {
70313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70314       };
70315     }
70316   }
70317 }
70318
70319
70320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70321   void * jresult ;
70322   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70323   int arg2 ;
70324   float arg3 ;
70325   Dali::Vector3 *arg4 = 0 ;
70326   Dali::Vector3 result;
70327
70328   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70329   arg2 = (int)jarg2;
70330   arg3 = (float)jarg3;
70331   arg4 = (Dali::Vector3 *)jarg4;
70332   if (!arg4) {
70333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70334     return 0;
70335   }
70336   {
70337     try {
70338       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70339     } catch (std::out_of_range& e) {
70340       {
70341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70342       };
70343     } catch (std::exception& e) {
70344       {
70345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70346       };
70347     } catch (...) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70350       };
70351     }
70352   }
70353   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70354   return jresult;
70355 }
70356
70357
70358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70359   void * jresult ;
70360   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70361   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70362
70363   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70364   {
70365     try {
70366       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70367     } catch (std::out_of_range& e) {
70368       {
70369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70370       };
70371     } catch (std::exception& e) {
70372       {
70373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70374       };
70375     } catch (...) {
70376       {
70377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70378       };
70379     }
70380   }
70381   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70382   return jresult;
70383 }
70384
70385
70386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70387   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70388
70389   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70390   {
70391     try {
70392       delete arg1;
70393     } catch (std::out_of_range& e) {
70394       {
70395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70396       };
70397     } catch (std::exception& e) {
70398       {
70399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70400       };
70401     } catch (...) {
70402       {
70403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70404       };
70405     }
70406   }
70407 }
70408
70409
70410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70411   unsigned int jresult ;
70412   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70413   unsigned int result;
70414
70415   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70416   {
70417     try {
70418       result = (unsigned int)(arg1)->GetNumberOfItems();
70419     } catch (std::out_of_range& e) {
70420       {
70421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70422       };
70423     } catch (std::exception& e) {
70424       {
70425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (...) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70430       };
70431     }
70432   }
70433   jresult = result;
70434   return jresult;
70435 }
70436
70437
70438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70439   void * jresult ;
70440   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70441   unsigned int arg2 ;
70442   Dali::Actor result;
70443
70444   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70445   arg2 = (unsigned int)jarg2;
70446   {
70447     try {
70448       result = (arg1)->NewItem(arg2);
70449     } catch (std::out_of_range& e) {
70450       {
70451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70452       };
70453     } catch (std::exception& e) {
70454       {
70455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70456       };
70457     } catch (...) {
70458       {
70459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70460       };
70461     }
70462   }
70463   jresult = new Dali::Actor((const Dali::Actor &)result);
70464   return jresult;
70465 }
70466
70467
70468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70469   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70470   unsigned int arg2 ;
70471   Dali::Actor arg3 ;
70472   Dali::Actor *argp3 ;
70473
70474   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70475   arg2 = (unsigned int)jarg2;
70476   argp3 = (Dali::Actor *)jarg3;
70477   if (!argp3) {
70478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70479     return ;
70480   }
70481   arg3 = *argp3;
70482   {
70483     try {
70484       (arg1)->ItemReleased(arg2,arg3);
70485     } catch (std::out_of_range& e) {
70486       {
70487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70488       };
70489     } catch (std::exception& e) {
70490       {
70491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70492       };
70493     } catch (...) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70496       };
70497     }
70498   }
70499 }
70500
70501
70502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70503   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70504   unsigned int arg2 ;
70505   Dali::Actor arg3 ;
70506   Dali::Actor *argp3 ;
70507
70508   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70509   arg2 = (unsigned int)jarg2;
70510   argp3 = (Dali::Actor *)jarg3;
70511   if (!argp3) {
70512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70513     return ;
70514   }
70515   arg3 = *argp3;
70516   {
70517     try {
70518       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70519     } catch (std::out_of_range& e) {
70520       {
70521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70522       };
70523     } catch (std::exception& e) {
70524       {
70525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70530       };
70531     }
70532   }
70533 }
70534
70535
70536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70537   void * jresult ;
70538   Dali::Toolkit::ItemFactory *result = 0 ;
70539
70540   {
70541     try {
70542       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70543     } catch (std::out_of_range& e) {
70544       {
70545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70546       };
70547     } catch (std::exception& e) {
70548       {
70549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70550       };
70551     } catch (...) {
70552       {
70553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70554       };
70555     }
70556   }
70557   jresult = (void *)result;
70558   return jresult;
70559 }
70560
70561
70562 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) {
70563   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70564   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70565   if (director) {
70566     director->swig_connect_director(callback0, callback1, callback2);
70567   }
70568 }
70569
70570
70571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70572   int jresult ;
70573   int result;
70574
70575   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70576   jresult = (int)result;
70577   return jresult;
70578 }
70579
70580
70581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70582   int jresult ;
70583   int result;
70584
70585   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70586   jresult = (int)result;
70587   return jresult;
70588 }
70589
70590
70591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70592   int jresult ;
70593   int result;
70594
70595   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70596   jresult = (int)result;
70597   return jresult;
70598 }
70599
70600
70601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70602   int jresult ;
70603   int result;
70604
70605   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70606   jresult = (int)result;
70607   return jresult;
70608 }
70609
70610
70611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70612   int jresult ;
70613   int result;
70614
70615   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70616   jresult = (int)result;
70617   return jresult;
70618 }
70619
70620
70621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70622   int jresult ;
70623   int result;
70624
70625   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70626   jresult = (int)result;
70627   return jresult;
70628 }
70629
70630
70631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70632   int jresult ;
70633   int result;
70634
70635   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70636   jresult = (int)result;
70637   return jresult;
70638 }
70639
70640
70641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70642   int jresult ;
70643   int result;
70644
70645   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70646   jresult = (int)result;
70647   return jresult;
70648 }
70649
70650
70651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70652   int jresult ;
70653   int result;
70654
70655   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70656   jresult = (int)result;
70657   return jresult;
70658 }
70659
70660
70661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70662   int jresult ;
70663   int result;
70664
70665   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70666   jresult = (int)result;
70667   return jresult;
70668 }
70669
70670
70671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70672   int jresult ;
70673   int result;
70674
70675   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70676   jresult = (int)result;
70677   return jresult;
70678 }
70679
70680
70681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70682   void * jresult ;
70683   Dali::Toolkit::ItemView::Property *result = 0 ;
70684
70685   {
70686     try {
70687       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70688     } catch (std::out_of_range& e) {
70689       {
70690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70691       };
70692     } catch (std::exception& e) {
70693       {
70694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70695       };
70696     } catch (...) {
70697       {
70698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70699       };
70700     }
70701   }
70702   jresult = (void *)result;
70703   return jresult;
70704 }
70705
70706
70707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70708   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70709
70710   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70711   {
70712     try {
70713       delete arg1;
70714     } catch (std::out_of_range& e) {
70715       {
70716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70717       };
70718     } catch (std::exception& e) {
70719       {
70720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70721       };
70722     } catch (...) {
70723       {
70724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70725       };
70726     }
70727   }
70728 }
70729
70730
70731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70732   void * jresult ;
70733   Dali::Toolkit::ItemView *result = 0 ;
70734
70735   {
70736     try {
70737       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70738     } catch (std::out_of_range& e) {
70739       {
70740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70741       };
70742     } catch (std::exception& e) {
70743       {
70744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70745       };
70746     } catch (...) {
70747       {
70748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70749       };
70750     }
70751   }
70752   jresult = (void *)result;
70753   return jresult;
70754 }
70755
70756
70757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70758   void * jresult ;
70759   Dali::Toolkit::ItemView *arg1 = 0 ;
70760   Dali::Toolkit::ItemView *result = 0 ;
70761
70762   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70763   if (!arg1) {
70764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70765     return 0;
70766   }
70767   {
70768     try {
70769       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70770     } catch (std::out_of_range& e) {
70771       {
70772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70773       };
70774     } catch (std::exception& e) {
70775       {
70776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70777       };
70778     } catch (...) {
70779       {
70780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70781       };
70782     }
70783   }
70784   jresult = (void *)result;
70785   return jresult;
70786 }
70787
70788
70789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70790   void * jresult ;
70791   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70792   Dali::Toolkit::ItemView *arg2 = 0 ;
70793   Dali::Toolkit::ItemView *result = 0 ;
70794
70795   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70796   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70797   if (!arg2) {
70798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70799     return 0;
70800   }
70801   {
70802     try {
70803       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70804     } catch (std::out_of_range& e) {
70805       {
70806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70807       };
70808     } catch (std::exception& e) {
70809       {
70810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70811       };
70812     } catch (...) {
70813       {
70814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70815       };
70816     }
70817   }
70818   jresult = (void *)result;
70819   return jresult;
70820 }
70821
70822
70823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70825
70826   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70827   {
70828     try {
70829       delete arg1;
70830     } catch (std::out_of_range& e) {
70831       {
70832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70833       };
70834     } catch (std::exception& e) {
70835       {
70836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70837       };
70838     } catch (...) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70841       };
70842     }
70843   }
70844 }
70845
70846
70847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70848   void * jresult ;
70849   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70850   Dali::Toolkit::ItemView result;
70851
70852   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70853   if (!arg1) {
70854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70855     return 0;
70856   }
70857   {
70858     try {
70859       result = Dali::Toolkit::ItemView::New(*arg1);
70860     } catch (std::out_of_range& e) {
70861       {
70862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70863       };
70864     } catch (std::exception& e) {
70865       {
70866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70867       };
70868     } catch (...) {
70869       {
70870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70871       };
70872     }
70873   }
70874   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70875   return jresult;
70876 }
70877
70878
70879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70880   void * jresult ;
70881   Dali::BaseHandle arg1 ;
70882   Dali::BaseHandle *argp1 ;
70883   Dali::Toolkit::ItemView result;
70884
70885   argp1 = (Dali::BaseHandle *)jarg1;
70886   if (!argp1) {
70887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70888     return 0;
70889   }
70890   arg1 = *argp1;
70891   {
70892     try {
70893       result = Dali::Toolkit::ItemView::DownCast(arg1);
70894     } catch (std::out_of_range& e) {
70895       {
70896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70897       };
70898     } catch (std::exception& e) {
70899       {
70900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70901       };
70902     } catch (...) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70905       };
70906     }
70907   }
70908   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70909   return jresult;
70910 }
70911
70912
70913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70914   unsigned int jresult ;
70915   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70916   unsigned int result;
70917
70918   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70919   {
70920     try {
70921       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70922     } catch (std::out_of_range& e) {
70923       {
70924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70925       };
70926     } catch (std::exception& e) {
70927       {
70928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70929       };
70930     } catch (...) {
70931       {
70932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70933       };
70934     }
70935   }
70936   jresult = result;
70937   return jresult;
70938 }
70939
70940
70941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70942   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70943   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70944
70945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70946   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70947   if (!arg2) {
70948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70949     return ;
70950   }
70951   {
70952     try {
70953       (arg1)->AddLayout(*arg2);
70954     } catch (std::out_of_range& e) {
70955       {
70956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70957       };
70958     } catch (std::exception& e) {
70959       {
70960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70961       };
70962     } catch (...) {
70963       {
70964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70965       };
70966     }
70967   }
70968 }
70969
70970
70971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70973   unsigned int arg2 ;
70974
70975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70976   arg2 = (unsigned int)jarg2;
70977   {
70978     try {
70979       (arg1)->RemoveLayout(arg2);
70980     } catch (std::out_of_range& e) {
70981       {
70982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70983       };
70984     } catch (std::exception& e) {
70985       {
70986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70987       };
70988     } catch (...) {
70989       {
70990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70991       };
70992     }
70993   }
70994 }
70995
70996
70997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70998   void * jresult ;
70999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71000   unsigned int arg2 ;
71001   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71002
71003   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71004   arg2 = (unsigned int)jarg2;
71005   {
71006     try {
71007       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71008     } catch (std::out_of_range& e) {
71009       {
71010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71011       };
71012     } catch (std::exception& e) {
71013       {
71014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71015       };
71016     } catch (...) {
71017       {
71018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71019       };
71020     }
71021   }
71022   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71023   return jresult;
71024 }
71025
71026
71027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71028   void * jresult ;
71029   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71030   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71031
71032   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71033   {
71034     try {
71035       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71036     } catch (std::out_of_range& e) {
71037       {
71038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71039       };
71040     } catch (std::exception& e) {
71041       {
71042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71043       };
71044     } catch (...) {
71045       {
71046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71047       };
71048     }
71049   }
71050   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71051   return jresult;
71052 }
71053
71054
71055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71056   float jresult ;
71057   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71058   Dali::Toolkit::ItemId arg2 ;
71059   float result;
71060
71061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71062   arg2 = (Dali::Toolkit::ItemId)jarg2;
71063   {
71064     try {
71065       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71066     } catch (std::out_of_range& e) {
71067       {
71068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71069       };
71070     } catch (std::exception& e) {
71071       {
71072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71073       };
71074     } catch (...) {
71075       {
71076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71077       };
71078     }
71079   }
71080   jresult = result;
71081   return jresult;
71082 }
71083
71084
71085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71087   unsigned int arg2 ;
71088   Dali::Vector3 arg3 ;
71089   float arg4 ;
71090   Dali::Vector3 *argp3 ;
71091
71092   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71093   arg2 = (unsigned int)jarg2;
71094   argp3 = (Dali::Vector3 *)jarg3;
71095   if (!argp3) {
71096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71097     return ;
71098   }
71099   arg3 = *argp3;
71100   arg4 = (float)jarg4;
71101   {
71102     try {
71103       (arg1)->ActivateLayout(arg2,arg3,arg4);
71104     } catch (std::out_of_range& e) {
71105       {
71106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (std::exception& e) {
71109       {
71110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71111       };
71112     } catch (...) {
71113       {
71114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71115       };
71116     }
71117   }
71118 }
71119
71120
71121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71122   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71123
71124   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71125   {
71126     try {
71127       (arg1)->DeactivateCurrentLayout();
71128     } catch (std::out_of_range& e) {
71129       {
71130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71131       };
71132     } catch (std::exception& e) {
71133       {
71134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71135       };
71136     } catch (...) {
71137       {
71138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71139       };
71140     }
71141   }
71142 }
71143
71144
71145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71146   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71147   float arg2 ;
71148
71149   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71150   arg2 = (float)jarg2;
71151   {
71152     try {
71153       (arg1)->SetMinimumSwipeSpeed(arg2);
71154     } catch (std::out_of_range& e) {
71155       {
71156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71157       };
71158     } catch (std::exception& e) {
71159       {
71160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71161       };
71162     } catch (...) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71165       };
71166     }
71167   }
71168 }
71169
71170
71171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71172   float jresult ;
71173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71174   float result;
71175
71176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71177   {
71178     try {
71179       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71180     } catch (std::out_of_range& e) {
71181       {
71182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71183       };
71184     } catch (std::exception& e) {
71185       {
71186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71187       };
71188     } catch (...) {
71189       {
71190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71191       };
71192     }
71193   }
71194   jresult = result;
71195   return jresult;
71196 }
71197
71198
71199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71201   float arg2 ;
71202
71203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71204   arg2 = (float)jarg2;
71205   {
71206     try {
71207       (arg1)->SetMinimumSwipeDistance(arg2);
71208     } catch (std::out_of_range& e) {
71209       {
71210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71211       };
71212     } catch (std::exception& e) {
71213       {
71214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71215       };
71216     } catch (...) {
71217       {
71218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71219       };
71220     }
71221   }
71222 }
71223
71224
71225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71226   float jresult ;
71227   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71228   float result;
71229
71230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71231   {
71232     try {
71233       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71234     } catch (std::out_of_range& e) {
71235       {
71236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (std::exception& e) {
71239       {
71240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71241       };
71242     } catch (...) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71245       };
71246     }
71247   }
71248   jresult = result;
71249   return jresult;
71250 }
71251
71252
71253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71254   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71255   float arg2 ;
71256
71257   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71258   arg2 = (float)jarg2;
71259   {
71260     try {
71261       (arg1)->SetWheelScrollDistanceStep(arg2);
71262     } catch (std::out_of_range& e) {
71263       {
71264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71265       };
71266     } catch (std::exception& e) {
71267       {
71268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71269       };
71270     } catch (...) {
71271       {
71272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71273       };
71274     }
71275   }
71276 }
71277
71278
71279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71280   float jresult ;
71281   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71282   float result;
71283
71284   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71285   {
71286     try {
71287       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71288     } catch (std::out_of_range& e) {
71289       {
71290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71291       };
71292     } catch (std::exception& e) {
71293       {
71294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71295       };
71296     } catch (...) {
71297       {
71298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71299       };
71300     }
71301   }
71302   jresult = result;
71303   return jresult;
71304 }
71305
71306
71307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71308   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71309   bool arg2 ;
71310
71311   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71312   arg2 = jarg2 ? true : false;
71313   {
71314     try {
71315       (arg1)->SetAnchoring(arg2);
71316     } catch (std::out_of_range& e) {
71317       {
71318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71319       };
71320     } catch (std::exception& e) {
71321       {
71322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71323       };
71324     } catch (...) {
71325       {
71326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71327       };
71328     }
71329   }
71330 }
71331
71332
71333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71334   unsigned int jresult ;
71335   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71336   bool result;
71337
71338   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71339   {
71340     try {
71341       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71342     } catch (std::out_of_range& e) {
71343       {
71344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71345       };
71346     } catch (std::exception& e) {
71347       {
71348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71349       };
71350     } catch (...) {
71351       {
71352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71353       };
71354     }
71355   }
71356   jresult = result;
71357   return jresult;
71358 }
71359
71360
71361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71362   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71363   float arg2 ;
71364
71365   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71366   arg2 = (float)jarg2;
71367   {
71368     try {
71369       (arg1)->SetAnchoringDuration(arg2);
71370     } catch (std::out_of_range& e) {
71371       {
71372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71373       };
71374     } catch (std::exception& e) {
71375       {
71376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71377       };
71378     } catch (...) {
71379       {
71380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71381       };
71382     }
71383   }
71384 }
71385
71386
71387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71388   float jresult ;
71389   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71390   float result;
71391
71392   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71393   {
71394     try {
71395       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71396     } catch (std::out_of_range& e) {
71397       {
71398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71399       };
71400     } catch (std::exception& e) {
71401       {
71402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71403       };
71404     } catch (...) {
71405       {
71406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71407       };
71408     }
71409   }
71410   jresult = result;
71411   return jresult;
71412 }
71413
71414
71415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71416   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71417   Dali::Toolkit::ItemId arg2 ;
71418   float arg3 ;
71419
71420   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71421   arg2 = (Dali::Toolkit::ItemId)jarg2;
71422   arg3 = (float)jarg3;
71423   {
71424     try {
71425       (arg1)->ScrollToItem(arg2,arg3);
71426     } catch (std::out_of_range& e) {
71427       {
71428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71429       };
71430     } catch (std::exception& e) {
71431       {
71432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71437       };
71438     }
71439   }
71440 }
71441
71442
71443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71444   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71445   float arg2 ;
71446
71447   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71448   arg2 = (float)jarg2;
71449   {
71450     try {
71451       (arg1)->SetRefreshInterval(arg2);
71452     } catch (std::out_of_range& e) {
71453       {
71454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71455       };
71456     } catch (std::exception& e) {
71457       {
71458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71459       };
71460     } catch (...) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71463       };
71464     }
71465   }
71466 }
71467
71468
71469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71470   float jresult ;
71471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71472   float result;
71473
71474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71475   {
71476     try {
71477       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71478     } catch (std::out_of_range& e) {
71479       {
71480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71481       };
71482     } catch (std::exception& e) {
71483       {
71484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71485       };
71486     } catch (...) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71489       };
71490     }
71491   }
71492   jresult = result;
71493   return jresult;
71494 }
71495
71496
71497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71498   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71499
71500   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71501   {
71502     try {
71503       (arg1)->Refresh();
71504     } catch (std::out_of_range& e) {
71505       {
71506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71507       };
71508     } catch (std::exception& e) {
71509       {
71510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71511       };
71512     } catch (...) {
71513       {
71514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71515       };
71516     }
71517   }
71518 }
71519
71520
71521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71522   void * jresult ;
71523   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71524   Dali::Toolkit::ItemId arg2 ;
71525   Dali::Actor result;
71526
71527   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71528   arg2 = (Dali::Toolkit::ItemId)jarg2;
71529   {
71530     try {
71531       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71532     } catch (std::out_of_range& e) {
71533       {
71534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71535       };
71536     } catch (std::exception& e) {
71537       {
71538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71539       };
71540     } catch (...) {
71541       {
71542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71543       };
71544     }
71545   }
71546   jresult = new Dali::Actor((const Dali::Actor &)result);
71547   return jresult;
71548 }
71549
71550
71551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71552   unsigned int jresult ;
71553   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71554   Dali::Actor arg2 ;
71555   Dali::Actor *argp2 ;
71556   Dali::Toolkit::ItemId result;
71557
71558   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71559   argp2 = (Dali::Actor *)jarg2;
71560   if (!argp2) {
71561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71562     return 0;
71563   }
71564   arg2 = *argp2;
71565   {
71566     try {
71567       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71568     } catch (std::out_of_range& e) {
71569       {
71570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71571       };
71572     } catch (std::exception& e) {
71573       {
71574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71575       };
71576     } catch (...) {
71577       {
71578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71579       };
71580     }
71581   }
71582   jresult = result;
71583   return jresult;
71584 }
71585
71586
71587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71588   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71589   Dali::Toolkit::Item arg2 ;
71590   float arg3 ;
71591   Dali::Toolkit::Item *argp2 ;
71592
71593   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71594   argp2 = (Dali::Toolkit::Item *)jarg2;
71595   if (!argp2) {
71596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71597     return ;
71598   }
71599   arg2 = *argp2;
71600   arg3 = (float)jarg3;
71601   {
71602     try {
71603       (arg1)->InsertItem(arg2,arg3);
71604     } catch (std::out_of_range& e) {
71605       {
71606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71607       };
71608     } catch (std::exception& e) {
71609       {
71610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71611       };
71612     } catch (...) {
71613       {
71614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71615       };
71616     }
71617   }
71618 }
71619
71620
71621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71622   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71623   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71624   float arg3 ;
71625
71626   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71627   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71628   if (!arg2) {
71629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71630     return ;
71631   }
71632   arg3 = (float)jarg3;
71633   {
71634     try {
71635       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71636     } catch (std::out_of_range& e) {
71637       {
71638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71639       };
71640     } catch (std::exception& e) {
71641       {
71642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71643       };
71644     } catch (...) {
71645       {
71646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71647       };
71648     }
71649   }
71650 }
71651
71652
71653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71654   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71655   Dali::Toolkit::ItemId arg2 ;
71656   float arg3 ;
71657
71658   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71659   arg2 = (Dali::Toolkit::ItemId)jarg2;
71660   arg3 = (float)jarg3;
71661   {
71662     try {
71663       (arg1)->RemoveItem(arg2,arg3);
71664     } catch (std::out_of_range& e) {
71665       {
71666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71667       };
71668     } catch (std::exception& e) {
71669       {
71670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71671       };
71672     } catch (...) {
71673       {
71674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71675       };
71676     }
71677   }
71678 }
71679
71680
71681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71682   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71683   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71684   float arg3 ;
71685
71686   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71687   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71688   if (!arg2) {
71689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71690     return ;
71691   }
71692   arg3 = (float)jarg3;
71693   {
71694     try {
71695       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71696     } catch (std::out_of_range& e) {
71697       {
71698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71699       };
71700     } catch (std::exception& e) {
71701       {
71702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71703       };
71704     } catch (...) {
71705       {
71706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71707       };
71708     }
71709   }
71710 }
71711
71712
71713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71714   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71715   Dali::Toolkit::Item arg2 ;
71716   float arg3 ;
71717   Dali::Toolkit::Item *argp2 ;
71718
71719   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71720   argp2 = (Dali::Toolkit::Item *)jarg2;
71721   if (!argp2) {
71722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71723     return ;
71724   }
71725   arg2 = *argp2;
71726   arg3 = (float)jarg3;
71727   {
71728     try {
71729       (arg1)->ReplaceItem(arg2,arg3);
71730     } catch (std::out_of_range& e) {
71731       {
71732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71733       };
71734     } catch (std::exception& e) {
71735       {
71736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71737       };
71738     } catch (...) {
71739       {
71740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71741       };
71742     }
71743   }
71744 }
71745
71746
71747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71748   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71749   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71750   float arg3 ;
71751
71752   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71753   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71754   if (!arg2) {
71755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71756     return ;
71757   }
71758   arg3 = (float)jarg3;
71759   {
71760     try {
71761       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71762     } catch (std::out_of_range& e) {
71763       {
71764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71765       };
71766     } catch (std::exception& e) {
71767       {
71768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71769       };
71770     } catch (...) {
71771       {
71772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71773       };
71774     }
71775   }
71776 }
71777
71778
71779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71781   Dali::Vector3 *arg2 = 0 ;
71782
71783   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71784   arg2 = (Dali::Vector3 *)jarg2;
71785   if (!arg2) {
71786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71787     return ;
71788   }
71789   {
71790     try {
71791       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71792     } catch (std::out_of_range& e) {
71793       {
71794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71795       };
71796     } catch (std::exception& e) {
71797       {
71798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71803       };
71804     }
71805   }
71806 }
71807
71808
71809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71810   void * jresult ;
71811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71812   Dali::Vector3 result;
71813
71814   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71815   {
71816     try {
71817       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71818     } catch (std::out_of_range& e) {
71819       {
71820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71821       };
71822     } catch (std::exception& e) {
71823       {
71824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71829       };
71830     }
71831   }
71832   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71833   return jresult;
71834 }
71835
71836
71837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71838   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71839   Dali::Vector3 *arg2 = 0 ;
71840
71841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71842   arg2 = (Dali::Vector3 *)jarg2;
71843   if (!arg2) {
71844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71845     return ;
71846   }
71847   {
71848     try {
71849       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71850     } catch (std::out_of_range& e) {
71851       {
71852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71853       };
71854     } catch (std::exception& e) {
71855       {
71856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71857       };
71858     } catch (...) {
71859       {
71860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71861       };
71862     }
71863   }
71864 }
71865
71866
71867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71868   void * jresult ;
71869   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71870   Dali::Vector3 result;
71871
71872   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71873   {
71874     try {
71875       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71876     } catch (std::out_of_range& e) {
71877       {
71878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71879       };
71880     } catch (std::exception& e) {
71881       {
71882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71883       };
71884     } catch (...) {
71885       {
71886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71887       };
71888     }
71889   }
71890   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71896   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71897   Dali::Toolkit::ItemRange *arg2 = 0 ;
71898
71899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71900   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71901   if (!arg2) {
71902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71903     return ;
71904   }
71905   {
71906     try {
71907       (arg1)->GetItemsRange(*arg2);
71908     } catch (std::out_of_range& e) {
71909       {
71910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71911       };
71912     } catch (std::exception& e) {
71913       {
71914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71915       };
71916     } catch (...) {
71917       {
71918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71919       };
71920     }
71921   }
71922 }
71923
71924
71925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71926   void * jresult ;
71927   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71928   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71929
71930   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71931   {
71932     try {
71933       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71934     } catch (std::out_of_range& e) {
71935       {
71936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71937       };
71938     } catch (std::exception& e) {
71939       {
71940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71941       };
71942     } catch (...) {
71943       {
71944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71945       };
71946     }
71947   }
71948   jresult = (void *)result;
71949   return jresult;
71950 }
71951
71952
71953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71954   Dali::Vector3 *arg1 = 0 ;
71955   PropertyInputContainer *arg2 = 0 ;
71956
71957   arg1 = (Dali::Vector3 *)jarg1;
71958   if (!arg1) {
71959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71960     return ;
71961   }
71962   arg2 = (PropertyInputContainer *)jarg2;
71963   if (!arg2) {
71964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71965     return ;
71966   }
71967   {
71968     try {
71969       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71970     } catch (std::out_of_range& e) {
71971       {
71972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71973       };
71974     } catch (std::exception& e) {
71975       {
71976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71977       };
71978     } catch (...) {
71979       {
71980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71981       };
71982     }
71983   }
71984 }
71985
71986
71987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71988   Dali::Vector3 *arg1 = 0 ;
71989   PropertyInputContainer *arg2 = 0 ;
71990
71991   arg1 = (Dali::Vector3 *)jarg1;
71992   if (!arg1) {
71993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71994     return ;
71995   }
71996   arg2 = (PropertyInputContainer *)jarg2;
71997   if (!arg2) {
71998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71999     return ;
72000   }
72001   {
72002     try {
72003       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72004     } catch (std::out_of_range& e) {
72005       {
72006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72007       };
72008     } catch (std::exception& e) {
72009       {
72010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72011       };
72012     } catch (...) {
72013       {
72014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72015       };
72016     }
72017   }
72018 }
72019
72020
72021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72022   void * jresult ;
72023   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72024
72025   {
72026     try {
72027       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72028     } catch (std::out_of_range& e) {
72029       {
72030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72031       };
72032     } catch (std::exception& e) {
72033       {
72034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72035       };
72036     } catch (...) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72039       };
72040     }
72041   }
72042   jresult = (void *)result;
72043   return jresult;
72044 }
72045
72046
72047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72048   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72049
72050   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72051   {
72052     try {
72053       delete arg1;
72054     } catch (std::out_of_range& e) {
72055       {
72056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72057       };
72058     } catch (std::exception& e) {
72059       {
72060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72061       };
72062     } catch (...) {
72063       {
72064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72065       };
72066     }
72067   }
72068 }
72069
72070
72071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72072   void * jresult ;
72073   Dali::Path arg1 ;
72074   Dali::Vector3 *arg2 = 0 ;
72075   Dali::Property::Index arg3 ;
72076   Dali::Vector3 *arg4 = 0 ;
72077   unsigned int arg5 ;
72078   Dali::Path *argp1 ;
72079   Dali::Toolkit::ScrollViewPagePathEffect result;
72080
72081   argp1 = (Dali::Path *)jarg1;
72082   if (!argp1) {
72083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72084     return 0;
72085   }
72086   arg1 = *argp1;
72087   arg2 = (Dali::Vector3 *)jarg2;
72088   if (!arg2) {
72089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72090     return 0;
72091   }
72092   arg3 = (Dali::Property::Index)jarg3;
72093   arg4 = (Dali::Vector3 *)jarg4;
72094   if (!arg4) {
72095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72096     return 0;
72097   }
72098   arg5 = (unsigned int)jarg5;
72099   {
72100     try {
72101       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72102     } catch (std::out_of_range& e) {
72103       {
72104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72105       };
72106     } catch (std::exception& e) {
72107       {
72108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (...) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72113       };
72114     }
72115   }
72116   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72117   return jresult;
72118 }
72119
72120
72121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72122   void * jresult ;
72123   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72124
72125   {
72126     try {
72127       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72128     } catch (std::out_of_range& e) {
72129       {
72130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72131       };
72132     } catch (std::exception& e) {
72133       {
72134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72135       };
72136     } catch (...) {
72137       {
72138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72139       };
72140     }
72141   }
72142   jresult = (void *)result;
72143   return jresult;
72144 }
72145
72146
72147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72148   void * jresult ;
72149   Dali::BaseHandle arg1 ;
72150   Dali::BaseHandle *argp1 ;
72151   Dali::Toolkit::ScrollViewPagePathEffect result;
72152
72153   argp1 = (Dali::BaseHandle *)jarg1;
72154   if (!argp1) {
72155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72156     return 0;
72157   }
72158   arg1 = *argp1;
72159   {
72160     try {
72161       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72162     } catch (std::out_of_range& e) {
72163       {
72164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72165       };
72166     } catch (std::exception& e) {
72167       {
72168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72169       };
72170     } catch (...) {
72171       {
72172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72173       };
72174     }
72175   }
72176   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72177   return jresult;
72178 }
72179
72180
72181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72182   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72183   Dali::Actor arg2 ;
72184   unsigned int arg3 ;
72185   Dali::Actor *argp2 ;
72186
72187   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72188   argp2 = (Dali::Actor *)jarg2;
72189   if (!argp2) {
72190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72191     return ;
72192   }
72193   arg2 = *argp2;
72194   arg3 = (unsigned int)jarg3;
72195   {
72196     try {
72197       (arg1)->ApplyToPage(arg2,arg3);
72198     } catch (std::out_of_range& e) {
72199       {
72200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72201       };
72202     } catch (std::exception& e) {
72203       {
72204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72209       };
72210     }
72211   }
72212 }
72213
72214
72215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72216   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72217
72218   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72219   {
72220     try {
72221       delete arg1;
72222     } catch (std::out_of_range& e) {
72223       {
72224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72225       };
72226     } catch (std::exception& e) {
72227       {
72228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72229       };
72230     } catch (...) {
72231       {
72232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72233       };
72234     }
72235   }
72236 }
72237
72238
72239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72240   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72241   Dali::Toolkit::ClampState arg2 ;
72242
72243   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72244   arg2 = (Dali::Toolkit::ClampState)jarg2;
72245   if (arg1) (arg1)->x = arg2;
72246 }
72247
72248
72249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72250   int jresult ;
72251   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72252   Dali::Toolkit::ClampState result;
72253
72254   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72255   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72256   jresult = (int)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72262   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72263   Dali::Toolkit::ClampState arg2 ;
72264
72265   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72266   arg2 = (Dali::Toolkit::ClampState)jarg2;
72267   if (arg1) (arg1)->y = arg2;
72268 }
72269
72270
72271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72272   int jresult ;
72273   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72274   Dali::Toolkit::ClampState result;
72275
72276   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72277   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72278   jresult = (int)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72284   void * jresult ;
72285   Dali::Toolkit::ClampState2D *result = 0 ;
72286
72287   {
72288     try {
72289       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72290     } catch (std::out_of_range& e) {
72291       {
72292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72293       };
72294     } catch (std::exception& e) {
72295       {
72296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72297       };
72298     } catch (...) {
72299       {
72300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72301       };
72302     }
72303   }
72304   jresult = (void *)result;
72305   return jresult;
72306 }
72307
72308
72309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72310   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72311
72312   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72313   {
72314     try {
72315       delete arg1;
72316     } catch (std::out_of_range& e) {
72317       {
72318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72319       };
72320     } catch (std::exception& e) {
72321       {
72322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72323       };
72324     } catch (...) {
72325       {
72326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72327       };
72328     }
72329   }
72330 }
72331
72332
72333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72334   void * jresult ;
72335   float arg1 ;
72336   float arg2 ;
72337   bool arg3 ;
72338   Dali::Toolkit::RulerDomain *result = 0 ;
72339
72340   arg1 = (float)jarg1;
72341   arg2 = (float)jarg2;
72342   arg3 = jarg3 ? true : false;
72343   {
72344     try {
72345       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72346     } catch (std::out_of_range& e) {
72347       {
72348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72349       };
72350     } catch (std::exception& e) {
72351       {
72352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72353       };
72354     } catch (...) {
72355       {
72356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72357       };
72358     }
72359   }
72360   jresult = (void *)result;
72361   return jresult;
72362 }
72363
72364
72365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72366   void * jresult ;
72367   float arg1 ;
72368   float arg2 ;
72369   Dali::Toolkit::RulerDomain *result = 0 ;
72370
72371   arg1 = (float)jarg1;
72372   arg2 = (float)jarg2;
72373   {
72374     try {
72375       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72376     } catch (std::out_of_range& e) {
72377       {
72378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72379       };
72380     } catch (std::exception& e) {
72381       {
72382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72383       };
72384     } catch (...) {
72385       {
72386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72387       };
72388     }
72389   }
72390   jresult = (void *)result;
72391   return jresult;
72392 }
72393
72394
72395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72396   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72397   float arg2 ;
72398
72399   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72400   arg2 = (float)jarg2;
72401   if (arg1) (arg1)->min = arg2;
72402 }
72403
72404
72405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72406   float jresult ;
72407   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72408   float result;
72409
72410   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72411   result = (float) ((arg1)->min);
72412   jresult = result;
72413   return jresult;
72414 }
72415
72416
72417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72418   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72419   float arg2 ;
72420
72421   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72422   arg2 = (float)jarg2;
72423   if (arg1) (arg1)->max = arg2;
72424 }
72425
72426
72427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72428   float jresult ;
72429   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72430   float result;
72431
72432   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72433   result = (float) ((arg1)->max);
72434   jresult = result;
72435   return jresult;
72436 }
72437
72438
72439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72440   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72441   bool arg2 ;
72442
72443   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72444   arg2 = jarg2 ? true : false;
72445   if (arg1) (arg1)->enabled = arg2;
72446 }
72447
72448
72449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72450   unsigned int jresult ;
72451   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72452   bool result;
72453
72454   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72455   result = (bool) ((arg1)->enabled);
72456   jresult = result;
72457   return jresult;
72458 }
72459
72460
72461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72462   float jresult ;
72463   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72464   float arg2 ;
72465   float arg3 ;
72466   float arg4 ;
72467   float result;
72468
72469   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72470   arg2 = (float)jarg2;
72471   arg3 = (float)jarg3;
72472   arg4 = (float)jarg4;
72473   {
72474     try {
72475       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72476     } catch (std::out_of_range& e) {
72477       {
72478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72479       };
72480     } catch (std::exception& e) {
72481       {
72482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72483       };
72484     } catch (...) {
72485       {
72486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72487       };
72488     }
72489   }
72490   jresult = result;
72491   return jresult;
72492 }
72493
72494
72495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72496   float jresult ;
72497   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72498   float arg2 ;
72499   float arg3 ;
72500   float result;
72501
72502   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72503   arg2 = (float)jarg2;
72504   arg3 = (float)jarg3;
72505   {
72506     try {
72507       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72508     } catch (std::out_of_range& e) {
72509       {
72510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (std::exception& e) {
72513       {
72514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72515       };
72516     } catch (...) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72519       };
72520     }
72521   }
72522   jresult = result;
72523   return jresult;
72524 }
72525
72526
72527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72528   float jresult ;
72529   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72530   float arg2 ;
72531   float result;
72532
72533   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72534   arg2 = (float)jarg2;
72535   {
72536     try {
72537       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72538     } catch (std::out_of_range& e) {
72539       {
72540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72541       };
72542     } catch (std::exception& e) {
72543       {
72544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72545       };
72546     } catch (...) {
72547       {
72548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72549       };
72550     }
72551   }
72552   jresult = result;
72553   return jresult;
72554 }
72555
72556
72557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72558   float jresult ;
72559   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72560   float arg2 ;
72561   float arg3 ;
72562   float arg4 ;
72563   Dali::Toolkit::ClampState *arg5 = 0 ;
72564   float result;
72565
72566   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72567   arg2 = (float)jarg2;
72568   arg3 = (float)jarg3;
72569   arg4 = (float)jarg4;
72570   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72571   if (!arg5) {
72572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72573     return 0;
72574   }
72575   {
72576     try {
72577       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72578     } catch (std::out_of_range& e) {
72579       {
72580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72581       };
72582     } catch (std::exception& e) {
72583       {
72584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72585       };
72586     } catch (...) {
72587       {
72588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72589       };
72590     }
72591   }
72592   jresult = result;
72593   return jresult;
72594 }
72595
72596
72597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72598   float jresult ;
72599   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72600   float result;
72601
72602   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72603   {
72604     try {
72605       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72606     } catch (std::out_of_range& e) {
72607       {
72608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72609       };
72610     } catch (std::exception& e) {
72611       {
72612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72613       };
72614     } catch (...) {
72615       {
72616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72617       };
72618     }
72619   }
72620   jresult = result;
72621   return jresult;
72622 }
72623
72624
72625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72626   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72627
72628   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72629   {
72630     try {
72631       delete arg1;
72632     } catch (std::out_of_range& e) {
72633       {
72634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72635       };
72636     } catch (std::exception& e) {
72637       {
72638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72639       };
72640     } catch (...) {
72641       {
72642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72643       };
72644     }
72645   }
72646 }
72647
72648
72649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72650   float jresult ;
72651   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72652   float arg2 ;
72653   float arg3 ;
72654   float result;
72655
72656   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72657   arg2 = (float)jarg2;
72658   arg3 = (float)jarg3;
72659   {
72660     try {
72661       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72662     } catch (std::out_of_range& e) {
72663       {
72664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72665       };
72666     } catch (std::exception& e) {
72667       {
72668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72669       };
72670     } catch (...) {
72671       {
72672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72673       };
72674     }
72675   }
72676   jresult = result;
72677   return jresult;
72678 }
72679
72680
72681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72682   float jresult ;
72683   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72684   float arg2 ;
72685   float result;
72686
72687   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72688   arg2 = (float)jarg2;
72689   {
72690     try {
72691       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72692     } catch (std::out_of_range& e) {
72693       {
72694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72695       };
72696     } catch (std::exception& e) {
72697       {
72698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72699       };
72700     } catch (...) {
72701       {
72702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72703       };
72704     }
72705   }
72706   jresult = result;
72707   return jresult;
72708 }
72709
72710
72711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72712   float jresult ;
72713   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72714   unsigned int arg2 ;
72715   unsigned int *arg3 = 0 ;
72716   bool arg4 ;
72717   float result;
72718
72719   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72720   arg2 = (unsigned int)jarg2;
72721   arg3 = (unsigned int *)jarg3;
72722   arg4 = jarg4 ? true : false;
72723   {
72724     try {
72725       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72726     } catch (std::out_of_range& e) {
72727       {
72728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (std::exception& e) {
72731       {
72732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (...) {
72735       {
72736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72737       };
72738     }
72739   }
72740   jresult = result;
72741   return jresult;
72742 }
72743
72744
72745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72746   unsigned int jresult ;
72747   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72748   float arg2 ;
72749   bool arg3 ;
72750   unsigned int result;
72751
72752   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72753   arg2 = (float)jarg2;
72754   arg3 = jarg3 ? true : false;
72755   {
72756     try {
72757       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72758     } catch (std::out_of_range& e) {
72759       {
72760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72761       };
72762     } catch (std::exception& e) {
72763       {
72764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72765       };
72766     } catch (...) {
72767       {
72768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72769       };
72770     }
72771   }
72772   jresult = result;
72773   return jresult;
72774 }
72775
72776
72777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72778   unsigned int jresult ;
72779   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72780   unsigned int result;
72781
72782   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72783   {
72784     try {
72785       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72786     } catch (std::out_of_range& e) {
72787       {
72788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72789       };
72790     } catch (std::exception& e) {
72791       {
72792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72793       };
72794     } catch (...) {
72795       {
72796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72797       };
72798     }
72799   }
72800   jresult = result;
72801   return jresult;
72802 }
72803
72804
72805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72806   int jresult ;
72807   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72808   Dali::Toolkit::Ruler::RulerType result;
72809
72810   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72811   {
72812     try {
72813       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72814     } catch (std::out_of_range& e) {
72815       {
72816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72817       };
72818     } catch (std::exception& e) {
72819       {
72820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72821       };
72822     } catch (...) {
72823       {
72824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72825       };
72826     }
72827   }
72828   jresult = (int)result;
72829   return jresult;
72830 }
72831
72832
72833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72834   unsigned int jresult ;
72835   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72836   bool result;
72837
72838   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72839   {
72840     try {
72841       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (...) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72853       };
72854     }
72855   }
72856   jresult = result;
72857   return jresult;
72858 }
72859
72860
72861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72862   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72863
72864   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72865   {
72866     try {
72867       (arg1)->Enable();
72868     } catch (std::out_of_range& e) {
72869       {
72870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72871       };
72872     } catch (std::exception& e) {
72873       {
72874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72875       };
72876     } catch (...) {
72877       {
72878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72879       };
72880     }
72881   }
72882 }
72883
72884
72885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72887
72888   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72889   {
72890     try {
72891       (arg1)->Disable();
72892     } catch (std::out_of_range& e) {
72893       {
72894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72895       };
72896     } catch (std::exception& e) {
72897       {
72898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72899       };
72900     } catch (...) {
72901       {
72902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72903       };
72904     }
72905   }
72906 }
72907
72908
72909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72910   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72911   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72912   Dali::Toolkit::RulerDomain *argp2 ;
72913
72914   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72915   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72916   if (!argp2) {
72917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72918     return ;
72919   }
72920   arg2 = *argp2;
72921   {
72922     try {
72923       (arg1)->SetDomain(arg2);
72924     } catch (std::out_of_range& e) {
72925       {
72926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72927       };
72928     } catch (std::exception& e) {
72929       {
72930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72931       };
72932     } catch (...) {
72933       {
72934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72935       };
72936     }
72937   }
72938 }
72939
72940
72941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72942   void * jresult ;
72943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72944   Dali::Toolkit::RulerDomain *result = 0 ;
72945
72946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72947   {
72948     try {
72949       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72957       };
72958     } catch (...) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72961       };
72962     }
72963   }
72964   jresult = (void *)result;
72965   return jresult;
72966 }
72967
72968
72969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72970   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72971
72972   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72973   {
72974     try {
72975       (arg1)->DisableDomain();
72976     } catch (std::out_of_range& e) {
72977       {
72978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72979       };
72980     } catch (std::exception& e) {
72981       {
72982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72983       };
72984     } catch (...) {
72985       {
72986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72987       };
72988     }
72989   }
72990 }
72991
72992
72993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72994   float jresult ;
72995   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72996   float arg2 ;
72997   float arg3 ;
72998   float arg4 ;
72999   float result;
73000
73001   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73002   arg2 = (float)jarg2;
73003   arg3 = (float)jarg3;
73004   arg4 = (float)jarg4;
73005   {
73006     try {
73007       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73008     } catch (std::out_of_range& e) {
73009       {
73010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73011       };
73012     } catch (std::exception& e) {
73013       {
73014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73015       };
73016     } catch (...) {
73017       {
73018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73019       };
73020     }
73021   }
73022   jresult = result;
73023   return jresult;
73024 }
73025
73026
73027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73028   float jresult ;
73029   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73030   float arg2 ;
73031   float arg3 ;
73032   float result;
73033
73034   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73035   arg2 = (float)jarg2;
73036   arg3 = (float)jarg3;
73037   {
73038     try {
73039       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73040     } catch (std::out_of_range& e) {
73041       {
73042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73043       };
73044     } catch (std::exception& e) {
73045       {
73046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73047       };
73048     } catch (...) {
73049       {
73050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73051       };
73052     }
73053   }
73054   jresult = result;
73055   return jresult;
73056 }
73057
73058
73059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73060   float jresult ;
73061   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73062   float arg2 ;
73063   float result;
73064
73065   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73066   arg2 = (float)jarg2;
73067   {
73068     try {
73069       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73070     } catch (std::out_of_range& e) {
73071       {
73072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73073       };
73074     } catch (std::exception& e) {
73075       {
73076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73077       };
73078     } catch (...) {
73079       {
73080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73081       };
73082     }
73083   }
73084   jresult = result;
73085   return jresult;
73086 }
73087
73088
73089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73090   float jresult ;
73091   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73092   float arg2 ;
73093   float arg3 ;
73094   float arg4 ;
73095   Dali::Toolkit::ClampState *arg5 = 0 ;
73096   float result;
73097
73098   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73099   arg2 = (float)jarg2;
73100   arg3 = (float)jarg3;
73101   arg4 = (float)jarg4;
73102   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73103   if (!arg5) {
73104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73105     return 0;
73106   }
73107   {
73108     try {
73109       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73110     } catch (std::out_of_range& e) {
73111       {
73112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73113       };
73114     } catch (std::exception& e) {
73115       {
73116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73117       };
73118     } catch (...) {
73119       {
73120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73121       };
73122     }
73123   }
73124   jresult = result;
73125   return jresult;
73126 }
73127
73128
73129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73130   float jresult ;
73131   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73132   float arg2 ;
73133   float arg3 ;
73134   float arg4 ;
73135   float arg5 ;
73136   float result;
73137
73138   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73139   arg2 = (float)jarg2;
73140   arg3 = (float)jarg3;
73141   arg4 = (float)jarg4;
73142   arg5 = (float)jarg5;
73143   {
73144     try {
73145       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73146     } catch (std::out_of_range& e) {
73147       {
73148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73149       };
73150     } catch (std::exception& e) {
73151       {
73152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73153       };
73154     } catch (...) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73157       };
73158     }
73159   }
73160   jresult = result;
73161   return jresult;
73162 }
73163
73164
73165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73166   float jresult ;
73167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73168   float arg2 ;
73169   float arg3 ;
73170   float arg4 ;
73171   float result;
73172
73173   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73174   arg2 = (float)jarg2;
73175   arg3 = (float)jarg3;
73176   arg4 = (float)jarg4;
73177   {
73178     try {
73179       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73180     } catch (std::out_of_range& e) {
73181       {
73182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73183       };
73184     } catch (std::exception& e) {
73185       {
73186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73187       };
73188     } catch (...) {
73189       {
73190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73191       };
73192     }
73193   }
73194   jresult = result;
73195   return jresult;
73196 }
73197
73198
73199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73200   float jresult ;
73201   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73202   float arg2 ;
73203   float arg3 ;
73204   float result;
73205
73206   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73207   arg2 = (float)jarg2;
73208   arg3 = (float)jarg3;
73209   {
73210     try {
73211       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73212     } catch (std::out_of_range& e) {
73213       {
73214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73215       };
73216     } catch (std::exception& e) {
73217       {
73218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73219       };
73220     } catch (...) {
73221       {
73222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73223       };
73224     }
73225   }
73226   jresult = result;
73227   return jresult;
73228 }
73229
73230
73231 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73232   float jresult ;
73233   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73234   float arg2 ;
73235   float result;
73236
73237   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73238   arg2 = (float)jarg2;
73239   {
73240     try {
73241       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73242     } catch (std::out_of_range& e) {
73243       {
73244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73245       };
73246     } catch (std::exception& e) {
73247       {
73248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73249       };
73250     } catch (...) {
73251       {
73252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73253       };
73254     }
73255   }
73256   jresult = result;
73257   return jresult;
73258 }
73259
73260
73261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73262   float jresult ;
73263   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73264   float arg2 ;
73265   float arg3 ;
73266   float arg4 ;
73267   float arg5 ;
73268   Dali::Toolkit::ClampState *arg6 = 0 ;
73269   float result;
73270
73271   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73272   arg2 = (float)jarg2;
73273   arg3 = (float)jarg3;
73274   arg4 = (float)jarg4;
73275   arg5 = (float)jarg5;
73276   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73277   if (!arg6) {
73278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73279     return 0;
73280   }
73281   {
73282     try {
73283       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (...) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73295       };
73296     }
73297   }
73298   jresult = result;
73299   return jresult;
73300 }
73301
73302
73303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73304   void * jresult ;
73305   Dali::Toolkit::DefaultRuler *result = 0 ;
73306
73307   {
73308     try {
73309       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (...) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73321       };
73322     }
73323   }
73324   jresult = (void *)result;
73325   return jresult;
73326 }
73327
73328
73329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73330   float jresult ;
73331   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73332   float arg2 ;
73333   float arg3 ;
73334   float result;
73335
73336   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73337   arg2 = (float)jarg2;
73338   arg3 = (float)jarg3;
73339   {
73340     try {
73341       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73342     } catch (std::out_of_range& e) {
73343       {
73344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73345       };
73346     } catch (std::exception& e) {
73347       {
73348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73349       };
73350     } catch (...) {
73351       {
73352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73353       };
73354     }
73355   }
73356   jresult = result;
73357   return jresult;
73358 }
73359
73360
73361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73362   float jresult ;
73363   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73364   unsigned int arg2 ;
73365   unsigned int *arg3 = 0 ;
73366   bool arg4 ;
73367   float result;
73368
73369   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73370   arg2 = (unsigned int)jarg2;
73371   arg3 = (unsigned int *)jarg3;
73372   arg4 = jarg4 ? true : false;
73373   {
73374     try {
73375       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73376     } catch (std::out_of_range& e) {
73377       {
73378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73379       };
73380     } catch (std::exception& e) {
73381       {
73382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (...) {
73385       {
73386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73387       };
73388     }
73389   }
73390   jresult = result;
73391   return jresult;
73392 }
73393
73394
73395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73396   unsigned int jresult ;
73397   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73398   float arg2 ;
73399   bool arg3 ;
73400   unsigned int result;
73401
73402   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73403   arg2 = (float)jarg2;
73404   arg3 = jarg3 ? true : false;
73405   {
73406     try {
73407       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73408     } catch (std::out_of_range& e) {
73409       {
73410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73411       };
73412     } catch (std::exception& e) {
73413       {
73414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73415       };
73416     } catch (...) {
73417       {
73418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73419       };
73420     }
73421   }
73422   jresult = result;
73423   return jresult;
73424 }
73425
73426
73427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73428   unsigned int jresult ;
73429   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73430   unsigned int result;
73431
73432   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73433   {
73434     try {
73435       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73436     } catch (std::out_of_range& e) {
73437       {
73438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73439       };
73440     } catch (std::exception& e) {
73441       {
73442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73443       };
73444     } catch (...) {
73445       {
73446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73447       };
73448     }
73449   }
73450   jresult = result;
73451   return jresult;
73452 }
73453
73454
73455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73456   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73457
73458   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73459   {
73460     try {
73461       delete arg1;
73462     } catch (std::out_of_range& e) {
73463       {
73464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73465       };
73466     } catch (std::exception& e) {
73467       {
73468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73469       };
73470     } catch (...) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73473       };
73474     }
73475   }
73476 }
73477
73478
73479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73480   void * jresult ;
73481   float arg1 ;
73482   Dali::Toolkit::FixedRuler *result = 0 ;
73483
73484   arg1 = (float)jarg1;
73485   {
73486     try {
73487       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73488     } catch (std::out_of_range& e) {
73489       {
73490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73491       };
73492     } catch (std::exception& e) {
73493       {
73494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73495       };
73496     } catch (...) {
73497       {
73498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73499       };
73500     }
73501   }
73502   jresult = (void *)result;
73503   return jresult;
73504 }
73505
73506
73507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73508   void * jresult ;
73509   Dali::Toolkit::FixedRuler *result = 0 ;
73510
73511   {
73512     try {
73513       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73514     } catch (std::out_of_range& e) {
73515       {
73516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73517       };
73518     } catch (std::exception& e) {
73519       {
73520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73521       };
73522     } catch (...) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73525       };
73526     }
73527   }
73528   jresult = (void *)result;
73529   return jresult;
73530 }
73531
73532
73533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73534   float jresult ;
73535   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73536   float arg2 ;
73537   float arg3 ;
73538   float result;
73539
73540   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73541   arg2 = (float)jarg2;
73542   arg3 = (float)jarg3;
73543   {
73544     try {
73545       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73546     } catch (std::out_of_range& e) {
73547       {
73548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73549       };
73550     } catch (std::exception& e) {
73551       {
73552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (...) {
73555       {
73556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73557       };
73558     }
73559   }
73560   jresult = result;
73561   return jresult;
73562 }
73563
73564
73565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73566   float jresult ;
73567   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73568   unsigned int arg2 ;
73569   unsigned int *arg3 = 0 ;
73570   bool arg4 ;
73571   float result;
73572
73573   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73574   arg2 = (unsigned int)jarg2;
73575   arg3 = (unsigned int *)jarg3;
73576   arg4 = jarg4 ? true : false;
73577   {
73578     try {
73579       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73580     } catch (std::out_of_range& e) {
73581       {
73582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73583       };
73584     } catch (std::exception& e) {
73585       {
73586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73587       };
73588     } catch (...) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73591       };
73592     }
73593   }
73594   jresult = result;
73595   return jresult;
73596 }
73597
73598
73599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73600   unsigned int jresult ;
73601   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73602   float arg2 ;
73603   bool arg3 ;
73604   unsigned int result;
73605
73606   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73607   arg2 = (float)jarg2;
73608   arg3 = jarg3 ? true : false;
73609   {
73610     try {
73611       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73612     } catch (std::out_of_range& e) {
73613       {
73614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73615       };
73616     } catch (std::exception& e) {
73617       {
73618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73619       };
73620     } catch (...) {
73621       {
73622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73623       };
73624     }
73625   }
73626   jresult = result;
73627   return jresult;
73628 }
73629
73630
73631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73632   unsigned int jresult ;
73633   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73634   unsigned int result;
73635
73636   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73637   {
73638     try {
73639       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73640     } catch (std::out_of_range& e) {
73641       {
73642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73643       };
73644     } catch (std::exception& e) {
73645       {
73646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73647       };
73648     } catch (...) {
73649       {
73650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73651       };
73652     }
73653   }
73654   jresult = result;
73655   return jresult;
73656 }
73657
73658
73659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73660   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73661
73662   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73663   {
73664     try {
73665       delete arg1;
73666     } catch (std::out_of_range& e) {
73667       {
73668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73669       };
73670     } catch (std::exception& e) {
73671       {
73672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73673       };
73674     } catch (...) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73677       };
73678     }
73679   }
73680 }
73681
73682
73683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73684   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73685   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73686
73687   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73688   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73689   if (arg1) (arg1)->scale = *arg2;
73690 }
73691
73692
73693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73694   void * jresult ;
73695   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73696   Dali::Toolkit::ClampState2D *result = 0 ;
73697
73698   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73699   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73700   jresult = (void *)result;
73701   return jresult;
73702 }
73703
73704
73705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73706   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73707   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73708
73709   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73710   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73711   if (arg1) (arg1)->position = *arg2;
73712 }
73713
73714
73715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73716   void * jresult ;
73717   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73718   Dali::Toolkit::ClampState2D *result = 0 ;
73719
73720   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73721   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73722   jresult = (void *)result;
73723   return jresult;
73724 }
73725
73726
73727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73728   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73729   Dali::Toolkit::ClampState arg2 ;
73730
73731   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73732   arg2 = (Dali::Toolkit::ClampState)jarg2;
73733   if (arg1) (arg1)->rotation = arg2;
73734 }
73735
73736
73737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73738   int jresult ;
73739   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73740   Dali::Toolkit::ClampState result;
73741
73742   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73743   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73744   jresult = (int)result;
73745   return jresult;
73746 }
73747
73748
73749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73750   void * jresult ;
73751   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73752
73753   {
73754     try {
73755       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (...) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73767       };
73768     }
73769   }
73770   jresult = (void *)result;
73771   return jresult;
73772 }
73773
73774
73775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73776   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73777
73778   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73779   {
73780     try {
73781       delete arg1;
73782     } catch (std::out_of_range& e) {
73783       {
73784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73785       };
73786     } catch (std::exception& e) {
73787       {
73788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73789       };
73790     } catch (...) {
73791       {
73792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73793       };
73794     }
73795   }
73796 }
73797
73798
73799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73800   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73801   Dali::Toolkit::SnapType arg2 ;
73802
73803   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73804   arg2 = (Dali::Toolkit::SnapType)jarg2;
73805   if (arg1) (arg1)->type = arg2;
73806 }
73807
73808
73809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73810   int jresult ;
73811   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73812   Dali::Toolkit::SnapType result;
73813
73814   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73815   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73816   jresult = (int)result;
73817   return jresult;
73818 }
73819
73820
73821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73822   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73823   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73824
73825   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73826   arg2 = (Dali::Vector2 *)jarg2;
73827   if (arg1) (arg1)->position = *arg2;
73828 }
73829
73830
73831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73832   void * jresult ;
73833   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73834   Dali::Vector2 *result = 0 ;
73835
73836   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73837   result = (Dali::Vector2 *)& ((arg1)->position);
73838   jresult = (void *)result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73844   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73845   float arg2 ;
73846
73847   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73848   arg2 = (float)jarg2;
73849   if (arg1) (arg1)->duration = arg2;
73850 }
73851
73852
73853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73854   float jresult ;
73855   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73856   float result;
73857
73858   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73859   result = (float) ((arg1)->duration);
73860   jresult = result;
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73866   void * jresult ;
73867   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73868
73869   {
73870     try {
73871       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73872     } catch (std::out_of_range& e) {
73873       {
73874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73875       };
73876     } catch (std::exception& e) {
73877       {
73878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73879       };
73880     } catch (...) {
73881       {
73882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73883       };
73884     }
73885   }
73886   jresult = (void *)result;
73887   return jresult;
73888 }
73889
73890
73891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73892   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73893
73894   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73895   {
73896     try {
73897       delete arg1;
73898     } catch (std::out_of_range& e) {
73899       {
73900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73901       };
73902     } catch (std::exception& e) {
73903       {
73904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73905       };
73906     } catch (...) {
73907       {
73908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73909       };
73910     }
73911   }
73912 }
73913
73914
73915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73916   int jresult ;
73917   int result;
73918
73919   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73920   jresult = (int)result;
73921   return jresult;
73922 }
73923
73924
73925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73926   int jresult ;
73927   int result;
73928
73929   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73930   jresult = (int)result;
73931   return jresult;
73932 }
73933
73934
73935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73936   int jresult ;
73937   int result;
73938
73939   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73940   jresult = (int)result;
73941   return jresult;
73942 }
73943
73944
73945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73946   int jresult ;
73947   int result;
73948
73949   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73950   jresult = (int)result;
73951   return jresult;
73952 }
73953
73954
73955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
73956   int jresult ;
73957   int result;
73958
73959   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
73960   jresult = (int)result;
73961   return jresult;
73962 }
73963
73964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
73965   int jresult ;
73966   int result;
73967
73968   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73969   jresult = (int)result;
73970   return jresult;
73971 }
73972
73973
73974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73975   int jresult ;
73976   int result;
73977
73978   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73979   jresult = (int)result;
73980   return jresult;
73981 }
73982
73983
73984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73985   int jresult ;
73986   int result;
73987
73988   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73989   jresult = (int)result;
73990   return jresult;
73991 }
73992
73993
73994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73995   int jresult ;
73996   int result;
73997
73998   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73999   jresult = (int)result;
74000   return jresult;
74001 }
74002
74003
74004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74005   int jresult ;
74006   int result;
74007
74008   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74009   jresult = (int)result;
74010   return jresult;
74011 }
74012
74013
74014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74015   int jresult ;
74016   int result;
74017
74018   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74019   jresult = (int)result;
74020   return jresult;
74021 }
74022
74023
74024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74025   int jresult ;
74026   int result;
74027
74028   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74029   jresult = (int)result;
74030   return jresult;
74031 }
74032
74033
74034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74035   int jresult ;
74036   int result;
74037
74038   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74039   jresult = (int)result;
74040   return jresult;
74041 }
74042
74043
74044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74045   int jresult ;
74046   int result;
74047
74048   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74049   jresult = (int)result;
74050   return jresult;
74051 }
74052
74053
74054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74055   int jresult ;
74056   int result;
74057
74058   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74059   jresult = (int)result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74065   int jresult ;
74066   int result;
74067
74068   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74069   jresult = (int)result;
74070   return jresult;
74071 }
74072
74073
74074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74075   int jresult ;
74076   int result;
74077
74078   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74079   jresult = (int)result;
74080   return jresult;
74081 }
74082
74083
74084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74085   int jresult ;
74086   int result;
74087
74088   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74089   jresult = (int)result;
74090   return jresult;
74091 }
74092
74093
74094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74095   int jresult ;
74096   int result;
74097
74098   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74099   jresult = (int)result;
74100   return jresult;
74101 }
74102
74103
74104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74105   int jresult ;
74106   int result;
74107
74108   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74109   jresult = (int)result;
74110   return jresult;
74111 }
74112
74113
74114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74115   int jresult ;
74116   int result;
74117
74118   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74119   jresult = (int)result;
74120   return jresult;
74121 }
74122
74123
74124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74125   int jresult ;
74126   int result;
74127
74128   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74129   jresult = (int)result;
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74135   int jresult ;
74136   int result;
74137
74138   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74139   jresult = (int)result;
74140   return jresult;
74141 }
74142
74143
74144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74145   int jresult ;
74146   int result;
74147
74148   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74149   jresult = (int)result;
74150   return jresult;
74151 }
74152
74153
74154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74155   int jresult ;
74156   int result;
74157
74158   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74159   jresult = (int)result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74165   int jresult ;
74166   int result;
74167
74168   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74169   jresult = (int)result;
74170   return jresult;
74171 }
74172
74173
74174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74175   void * jresult ;
74176   Dali::Toolkit::ScrollView::Property *result = 0 ;
74177
74178   {
74179     try {
74180       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74181     } catch (std::out_of_range& e) {
74182       {
74183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74184       };
74185     } catch (std::exception& e) {
74186       {
74187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74188       };
74189     } catch (...) {
74190       {
74191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74192       };
74193     }
74194   }
74195   jresult = (void *)result;
74196   return jresult;
74197 }
74198
74199
74200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74201   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74202
74203   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74204   {
74205     try {
74206       delete arg1;
74207     } catch (std::out_of_range& e) {
74208       {
74209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74210       };
74211     } catch (std::exception& e) {
74212       {
74213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74214       };
74215     } catch (...) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74218       };
74219     }
74220   }
74221 }
74222
74223
74224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74225   void * jresult ;
74226   Dali::Toolkit::ScrollView *result = 0 ;
74227
74228   {
74229     try {
74230       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74231     } catch (std::out_of_range& e) {
74232       {
74233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74234       };
74235     } catch (std::exception& e) {
74236       {
74237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74238       };
74239     } catch (...) {
74240       {
74241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74242       };
74243     }
74244   }
74245   jresult = (void *)result;
74246   return jresult;
74247 }
74248
74249
74250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74251   void * jresult ;
74252   Dali::Toolkit::ScrollView *arg1 = 0 ;
74253   Dali::Toolkit::ScrollView *result = 0 ;
74254
74255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74256   if (!arg1) {
74257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74258     return 0;
74259   }
74260   {
74261     try {
74262       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74263     } catch (std::out_of_range& e) {
74264       {
74265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74266       };
74267     } catch (std::exception& e) {
74268       {
74269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (...) {
74272       {
74273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74274       };
74275     }
74276   }
74277   jresult = (void *)result;
74278   return jresult;
74279 }
74280
74281
74282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74283   void * jresult ;
74284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74285   Dali::Toolkit::ScrollView *arg2 = 0 ;
74286   Dali::Toolkit::ScrollView *result = 0 ;
74287
74288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74289   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74290   if (!arg2) {
74291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74292     return 0;
74293   }
74294   {
74295     try {
74296       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74297     } catch (std::out_of_range& e) {
74298       {
74299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74300       };
74301     } catch (std::exception& e) {
74302       {
74303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74304       };
74305     } catch (...) {
74306       {
74307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74308       };
74309     }
74310   }
74311   jresult = (void *)result;
74312   return jresult;
74313 }
74314
74315
74316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74318
74319   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74320   {
74321     try {
74322       delete arg1;
74323     } catch (std::out_of_range& e) {
74324       {
74325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74326       };
74327     } catch (std::exception& e) {
74328       {
74329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74330       };
74331     } catch (...) {
74332       {
74333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74334       };
74335     }
74336   }
74337 }
74338
74339
74340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74341   void * jresult ;
74342   Dali::Toolkit::ScrollView result;
74343
74344   {
74345     try {
74346       result = Dali::Toolkit::ScrollView::New();
74347     } catch (std::out_of_range& e) {
74348       {
74349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74350       };
74351     } catch (std::exception& e) {
74352       {
74353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74354       };
74355     } catch (...) {
74356       {
74357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74358       };
74359     }
74360   }
74361   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74362   return jresult;
74363 }
74364
74365
74366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74367   void * jresult ;
74368   Dali::BaseHandle arg1 ;
74369   Dali::BaseHandle *argp1 ;
74370   Dali::Toolkit::ScrollView result;
74371
74372   argp1 = (Dali::BaseHandle *)jarg1;
74373   if (!argp1) {
74374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74375     return 0;
74376   }
74377   arg1 = *argp1;
74378   {
74379     try {
74380       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74381     } catch (std::out_of_range& e) {
74382       {
74383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74384       };
74385     } catch (std::exception& e) {
74386       {
74387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74388       };
74389     } catch (...) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74392       };
74393     }
74394   }
74395   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74396   return jresult;
74397 }
74398
74399
74400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74401   void * jresult ;
74402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74403   Dali::AlphaFunction result;
74404
74405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74406   {
74407     try {
74408       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74409     } catch (std::out_of_range& e) {
74410       {
74411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74412       };
74413     } catch (std::exception& e) {
74414       {
74415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74416       };
74417     } catch (...) {
74418       {
74419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74420       };
74421     }
74422   }
74423   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74424   return jresult;
74425 }
74426
74427
74428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74430   Dali::AlphaFunction arg2 ;
74431   Dali::AlphaFunction *argp2 ;
74432
74433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74434   argp2 = (Dali::AlphaFunction *)jarg2;
74435   if (!argp2) {
74436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74437     return ;
74438   }
74439   arg2 = *argp2;
74440   {
74441     try {
74442       (arg1)->SetScrollSnapAlphaFunction(arg2);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74450       };
74451     } catch (...) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74454       };
74455     }
74456   }
74457 }
74458
74459
74460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74461   void * jresult ;
74462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74463   Dali::AlphaFunction result;
74464
74465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74466   {
74467     try {
74468       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74469     } catch (std::out_of_range& e) {
74470       {
74471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74472       };
74473     } catch (std::exception& e) {
74474       {
74475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74476       };
74477     } catch (...) {
74478       {
74479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74480       };
74481     }
74482   }
74483   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74484   return jresult;
74485 }
74486
74487
74488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74490   Dali::AlphaFunction arg2 ;
74491   Dali::AlphaFunction *argp2 ;
74492
74493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74494   argp2 = (Dali::AlphaFunction *)jarg2;
74495   if (!argp2) {
74496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74497     return ;
74498   }
74499   arg2 = *argp2;
74500   {
74501     try {
74502       (arg1)->SetScrollFlickAlphaFunction(arg2);
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74510       };
74511     } catch (...) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74514       };
74515     }
74516   }
74517 }
74518
74519
74520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74521   float jresult ;
74522   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74523   float result;
74524
74525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74526   {
74527     try {
74528       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74529     } catch (std::out_of_range& e) {
74530       {
74531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74532       };
74533     } catch (std::exception& e) {
74534       {
74535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74540       };
74541     }
74542   }
74543   jresult = result;
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74549   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74550   float arg2 ;
74551
74552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74553   arg2 = (float)jarg2;
74554   {
74555     try {
74556       (arg1)->SetScrollSnapDuration(arg2);
74557     } catch (std::out_of_range& e) {
74558       {
74559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74560       };
74561     } catch (std::exception& e) {
74562       {
74563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74568       };
74569     }
74570   }
74571 }
74572
74573
74574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74575   float jresult ;
74576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74577   float result;
74578
74579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74580   {
74581     try {
74582       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74583     } catch (std::out_of_range& e) {
74584       {
74585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74586       };
74587     } catch (std::exception& e) {
74588       {
74589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74594       };
74595     }
74596   }
74597   jresult = result;
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74603   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74604   float arg2 ;
74605
74606   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74607   arg2 = (float)jarg2;
74608   {
74609     try {
74610       (arg1)->SetScrollFlickDuration(arg2);
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74618       };
74619     } catch (...) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74622       };
74623     }
74624   }
74625 }
74626
74627
74628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74630   Dali::Toolkit::RulerPtr arg2 ;
74631   Dali::Toolkit::RulerPtr *argp2 ;
74632
74633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74634   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74635   if (!argp2) {
74636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74637     return ;
74638   }
74639   arg2 = *argp2;
74640   {
74641     try {
74642       (arg1)->SetRulerX(arg2);
74643     } catch (std::out_of_range& e) {
74644       {
74645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74646       };
74647     } catch (std::exception& e) {
74648       {
74649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74650       };
74651     } catch (...) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74654       };
74655     }
74656   }
74657 }
74658
74659
74660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74662   Dali::Toolkit::RulerPtr arg2 ;
74663   Dali::Toolkit::RulerPtr *argp2 ;
74664
74665   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74666   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74667   if (!argp2) {
74668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74669     return ;
74670   }
74671   arg2 = *argp2;
74672   {
74673     try {
74674       (arg1)->SetRulerY(arg2);
74675     } catch (std::out_of_range& e) {
74676       {
74677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74678       };
74679     } catch (std::exception& e) {
74680       {
74681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74682       };
74683     } catch (...) {
74684       {
74685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74686       };
74687     }
74688   }
74689 }
74690
74691
74692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74694   bool arg2 ;
74695
74696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74697   arg2 = jarg2 ? true : false;
74698   {
74699     try {
74700       (arg1)->SetScrollSensitive(arg2);
74701     } catch (std::out_of_range& e) {
74702       {
74703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74704       };
74705     } catch (std::exception& e) {
74706       {
74707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74708       };
74709     } catch (...) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74712       };
74713     }
74714   }
74715 }
74716
74717
74718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74720   float arg2 ;
74721   float arg3 ;
74722
74723   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74724   arg2 = (float)jarg2;
74725   arg3 = (float)jarg3;
74726   {
74727     try {
74728       (arg1)->SetMaxOvershoot(arg2,arg3);
74729     } catch (std::out_of_range& e) {
74730       {
74731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74732       };
74733     } catch (std::exception& e) {
74734       {
74735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74736       };
74737     } catch (...) {
74738       {
74739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74740       };
74741     }
74742   }
74743 }
74744
74745
74746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74747   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74748   Dali::AlphaFunction arg2 ;
74749   Dali::AlphaFunction *argp2 ;
74750
74751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74752   argp2 = (Dali::AlphaFunction *)jarg2;
74753   if (!argp2) {
74754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74755     return ;
74756   }
74757   arg2 = *argp2;
74758   {
74759     try {
74760       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74761     } catch (std::out_of_range& e) {
74762       {
74763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74764       };
74765     } catch (std::exception& e) {
74766       {
74767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74768       };
74769     } catch (...) {
74770       {
74771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74772       };
74773     }
74774   }
74775 }
74776
74777
74778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74780   float arg2 ;
74781
74782   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74783   arg2 = (float)jarg2;
74784   {
74785     try {
74786       (arg1)->SetSnapOvershootDuration(arg2);
74787     } catch (std::out_of_range& e) {
74788       {
74789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74790       };
74791     } catch (std::exception& e) {
74792       {
74793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74794       };
74795     } catch (...) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74798       };
74799     }
74800   }
74801 }
74802
74803
74804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74806   bool arg2 ;
74807
74808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74809   arg2 = jarg2 ? true : false;
74810   {
74811     try {
74812       (arg1)->SetActorAutoSnap(arg2);
74813     } catch (std::out_of_range& e) {
74814       {
74815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74816       };
74817     } catch (std::exception& e) {
74818       {
74819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74824       };
74825     }
74826   }
74827 }
74828
74829
74830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74832   bool arg2 ;
74833
74834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74835   arg2 = jarg2 ? true : false;
74836   {
74837     try {
74838       (arg1)->SetWrapMode(arg2);
74839     } catch (std::out_of_range& e) {
74840       {
74841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (std::exception& e) {
74844       {
74845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74846       };
74847     } catch (...) {
74848       {
74849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74850       };
74851     }
74852   }
74853 }
74854
74855
74856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74857   int jresult ;
74858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74859   int result;
74860
74861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74862   {
74863     try {
74864       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
74865     } catch (std::out_of_range& e) {
74866       {
74867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74868       };
74869     } catch (std::exception& e) {
74870       {
74871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74872       };
74873     } catch (...) {
74874       {
74875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74876       };
74877     }
74878   }
74879   jresult = result;
74880   return jresult;
74881 }
74882
74883
74884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
74885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74886   int arg2 ;
74887
74888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74889   arg2 = (int)jarg2;
74890   {
74891     try {
74892       (arg1)->SetScrollUpdateDistance(arg2);
74893     } catch (std::out_of_range& e) {
74894       {
74895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74896       };
74897     } catch (std::exception& e) {
74898       {
74899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74900       };
74901     } catch (...) {
74902       {
74903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74904       };
74905     }
74906   }
74907 }
74908
74909
74910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
74911   unsigned int jresult ;
74912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74913   bool result;
74914
74915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74916   {
74917     try {
74918       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
74919     } catch (std::out_of_range& e) {
74920       {
74921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74922       };
74923     } catch (std::exception& e) {
74924       {
74925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74926       };
74927     } catch (...) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74930       };
74931     }
74932   }
74933   jresult = result;
74934   return jresult;
74935 }
74936
74937
74938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
74939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74940   bool arg2 ;
74941
74942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74943   arg2 = jarg2 ? true : false;
74944   {
74945     try {
74946       (arg1)->SetAxisAutoLock(arg2);
74947     } catch (std::out_of_range& e) {
74948       {
74949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74950       };
74951     } catch (std::exception& e) {
74952       {
74953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74958       };
74959     }
74960   }
74961 }
74962
74963
74964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
74965   float jresult ;
74966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74967   float result;
74968
74969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74970   {
74971     try {
74972       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74973     } catch (std::out_of_range& e) {
74974       {
74975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74976       };
74977     } catch (std::exception& e) {
74978       {
74979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74980       };
74981     } catch (...) {
74982       {
74983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74984       };
74985     }
74986   }
74987   jresult = result;
74988   return jresult;
74989 }
74990
74991
74992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74994   float arg2 ;
74995
74996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74997   arg2 = (float)jarg2;
74998   {
74999     try {
75000       (arg1)->SetAxisAutoLockGradient(arg2);
75001     } catch (std::out_of_range& e) {
75002       {
75003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75004       };
75005     } catch (std::exception& e) {
75006       {
75007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75008       };
75009     } catch (...) {
75010       {
75011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75012       };
75013     }
75014   }
75015 }
75016
75017
75018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75019   float jresult ;
75020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75021   float result;
75022
75023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75024   {
75025     try {
75026       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75027     } catch (std::out_of_range& e) {
75028       {
75029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75030       };
75031     } catch (std::exception& e) {
75032       {
75033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75034       };
75035     } catch (...) {
75036       {
75037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75038       };
75039     }
75040   }
75041   jresult = result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75048   float arg2 ;
75049
75050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75051   arg2 = (float)jarg2;
75052   {
75053     try {
75054       (arg1)->SetFrictionCoefficient(arg2);
75055     } catch (std::out_of_range& e) {
75056       {
75057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75058       };
75059     } catch (std::exception& e) {
75060       {
75061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (...) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75066       };
75067     }
75068   }
75069 }
75070
75071
75072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75073   float jresult ;
75074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75075   float result;
75076
75077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75078   {
75079     try {
75080       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75081     } catch (std::out_of_range& e) {
75082       {
75083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75084       };
75085     } catch (std::exception& e) {
75086       {
75087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75088       };
75089     } catch (...) {
75090       {
75091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75092       };
75093     }
75094   }
75095   jresult = result;
75096   return jresult;
75097 }
75098
75099
75100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75102   float arg2 ;
75103
75104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75105   arg2 = (float)jarg2;
75106   {
75107     try {
75108       (arg1)->SetFlickSpeedCoefficient(arg2);
75109     } catch (std::out_of_range& e) {
75110       {
75111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75112       };
75113     } catch (std::exception& e) {
75114       {
75115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75116       };
75117     } catch (...) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75120       };
75121     }
75122   }
75123 }
75124
75125
75126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75127   void * jresult ;
75128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75129   Dali::Vector2 result;
75130
75131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75132   {
75133     try {
75134       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75135     } catch (std::out_of_range& e) {
75136       {
75137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75138       };
75139     } catch (std::exception& e) {
75140       {
75141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75142       };
75143     } catch (...) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75146       };
75147     }
75148   }
75149   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75150   return jresult;
75151 }
75152
75153
75154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75156   Dali::Vector2 *arg2 = 0 ;
75157
75158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75159   arg2 = (Dali::Vector2 *)jarg2;
75160   if (!arg2) {
75161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75162     return ;
75163   }
75164   {
75165     try {
75166       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75178       };
75179     }
75180   }
75181 }
75182
75183
75184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75185   float jresult ;
75186   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75187   float result;
75188
75189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75190   {
75191     try {
75192       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75200       };
75201     } catch (...) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75204       };
75205     }
75206   }
75207   jresult = result;
75208   return jresult;
75209 }
75210
75211
75212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75214   float arg2 ;
75215
75216   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75217   arg2 = (float)jarg2;
75218   {
75219     try {
75220       (arg1)->SetMinimumSpeedForFlick(arg2);
75221     } catch (std::out_of_range& e) {
75222       {
75223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75224       };
75225     } catch (std::exception& e) {
75226       {
75227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75232       };
75233     }
75234   }
75235 }
75236
75237
75238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75239   float jresult ;
75240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75241   float result;
75242
75243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75244   {
75245     try {
75246       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (...) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75258       };
75259     }
75260   }
75261   jresult = result;
75262   return jresult;
75263 }
75264
75265
75266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75268   float arg2 ;
75269
75270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75271   arg2 = (float)jarg2;
75272   {
75273     try {
75274       (arg1)->SetMaxFlickSpeed(arg2);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75282       };
75283     } catch (...) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75286       };
75287     }
75288   }
75289 }
75290
75291
75292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75293   void * jresult ;
75294   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75295   Dali::Vector2 result;
75296
75297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75298   {
75299     try {
75300       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75301     } catch (std::out_of_range& e) {
75302       {
75303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75304       };
75305     } catch (std::exception& e) {
75306       {
75307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75308       };
75309     } catch (...) {
75310       {
75311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75312       };
75313     }
75314   }
75315   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75316   return jresult;
75317 }
75318
75319
75320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75322   Dali::Vector2 arg2 ;
75323   Dali::Vector2 *argp2 ;
75324
75325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75326   argp2 = (Dali::Vector2 *)jarg2;
75327   if (!argp2) {
75328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75329     return ;
75330   }
75331   arg2 = *argp2;
75332   {
75333     try {
75334       (arg1)->SetWheelScrollDistanceStep(arg2);
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75346       };
75347     }
75348   }
75349 }
75350
75351
75352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75353   void * jresult ;
75354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75355   Dali::Vector2 result;
75356
75357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75358   {
75359     try {
75360       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75361     } catch (std::out_of_range& e) {
75362       {
75363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75364       };
75365     } catch (std::exception& e) {
75366       {
75367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75368       };
75369     } catch (...) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75372       };
75373     }
75374   }
75375   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75376   return jresult;
75377 }
75378
75379
75380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75381   unsigned int jresult ;
75382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75383   unsigned int result;
75384
75385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75386   {
75387     try {
75388       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75389     } catch (std::out_of_range& e) {
75390       {
75391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75392       };
75393     } catch (std::exception& e) {
75394       {
75395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75396       };
75397     } catch (...) {
75398       {
75399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75400       };
75401     }
75402   }
75403   jresult = result;
75404   return jresult;
75405 }
75406
75407
75408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75410   Dali::Vector2 *arg2 = 0 ;
75411
75412   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75413   arg2 = (Dali::Vector2 *)jarg2;
75414   if (!arg2) {
75415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75416     return ;
75417   }
75418   {
75419     try {
75420       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75421     } catch (std::out_of_range& e) {
75422       {
75423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75424       };
75425     } catch (std::exception& e) {
75426       {
75427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75428       };
75429     } catch (...) {
75430       {
75431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75432       };
75433     }
75434   }
75435 }
75436
75437
75438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75440   Dali::Vector2 *arg2 = 0 ;
75441   float arg3 ;
75442
75443   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75444   arg2 = (Dali::Vector2 *)jarg2;
75445   if (!arg2) {
75446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75447     return ;
75448   }
75449   arg3 = (float)jarg3;
75450   {
75451     try {
75452       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75453     } catch (std::out_of_range& e) {
75454       {
75455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75456       };
75457     } catch (std::exception& e) {
75458       {
75459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75460       };
75461     } catch (...) {
75462       {
75463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75464       };
75465     }
75466   }
75467 }
75468
75469
75470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75472   Dali::Vector2 *arg2 = 0 ;
75473   float arg3 ;
75474   Dali::AlphaFunction arg4 ;
75475   Dali::AlphaFunction *argp4 ;
75476
75477   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75478   arg2 = (Dali::Vector2 *)jarg2;
75479   if (!arg2) {
75480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75481     return ;
75482   }
75483   arg3 = (float)jarg3;
75484   argp4 = (Dali::AlphaFunction *)jarg4;
75485   if (!argp4) {
75486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75487     return ;
75488   }
75489   arg4 = *argp4;
75490   {
75491     try {
75492       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75493     } catch (std::out_of_range& e) {
75494       {
75495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75496       };
75497     } catch (std::exception& e) {
75498       {
75499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75500       };
75501     } catch (...) {
75502       {
75503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75504       };
75505     }
75506   }
75507 }
75508
75509
75510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75512   Dali::Vector2 *arg2 = 0 ;
75513   float arg3 ;
75514   Dali::Toolkit::DirectionBias arg4 ;
75515   Dali::Toolkit::DirectionBias arg5 ;
75516
75517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75518   arg2 = (Dali::Vector2 *)jarg2;
75519   if (!arg2) {
75520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75521     return ;
75522   }
75523   arg3 = (float)jarg3;
75524   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75525   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75526   {
75527     try {
75528       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75529     } catch (std::out_of_range& e) {
75530       {
75531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75532       };
75533     } catch (std::exception& e) {
75534       {
75535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75536       };
75537     } catch (...) {
75538       {
75539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75540       };
75541     }
75542   }
75543 }
75544
75545
75546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75548   Dali::Vector2 *arg2 = 0 ;
75549   float arg3 ;
75550   Dali::AlphaFunction arg4 ;
75551   Dali::Toolkit::DirectionBias arg5 ;
75552   Dali::Toolkit::DirectionBias arg6 ;
75553   Dali::AlphaFunction *argp4 ;
75554
75555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75556   arg2 = (Dali::Vector2 *)jarg2;
75557   if (!arg2) {
75558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75559     return ;
75560   }
75561   arg3 = (float)jarg3;
75562   argp4 = (Dali::AlphaFunction *)jarg4;
75563   if (!argp4) {
75564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75565     return ;
75566   }
75567   arg4 = *argp4;
75568   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75569   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75570   {
75571     try {
75572       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75573     } catch (std::out_of_range& e) {
75574       {
75575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75576       };
75577     } catch (std::exception& e) {
75578       {
75579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75580       };
75581     } catch (...) {
75582       {
75583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75584       };
75585     }
75586   }
75587 }
75588
75589
75590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75592   unsigned int arg2 ;
75593
75594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75595   arg2 = (unsigned int)jarg2;
75596   {
75597     try {
75598       (arg1)->ScrollTo(arg2);
75599     } catch (std::out_of_range& e) {
75600       {
75601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75602       };
75603     } catch (std::exception& e) {
75604       {
75605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75606       };
75607     } catch (...) {
75608       {
75609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75610       };
75611     }
75612   }
75613 }
75614
75615
75616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75618   unsigned int arg2 ;
75619   float arg3 ;
75620
75621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75622   arg2 = (unsigned int)jarg2;
75623   arg3 = (float)jarg3;
75624   {
75625     try {
75626       (arg1)->ScrollTo(arg2,arg3);
75627     } catch (std::out_of_range& e) {
75628       {
75629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75630       };
75631     } catch (std::exception& e) {
75632       {
75633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (...) {
75636       {
75637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75638       };
75639     }
75640   }
75641 }
75642
75643
75644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75645   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75646   unsigned int arg2 ;
75647   float arg3 ;
75648   Dali::Toolkit::DirectionBias arg4 ;
75649
75650   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75651   arg2 = (unsigned int)jarg2;
75652   arg3 = (float)jarg3;
75653   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75654   {
75655     try {
75656       (arg1)->ScrollTo(arg2,arg3,arg4);
75657     } catch (std::out_of_range& e) {
75658       {
75659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75660       };
75661     } catch (std::exception& e) {
75662       {
75663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (...) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75668       };
75669     }
75670   }
75671 }
75672
75673
75674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75676   Dali::Actor *arg2 = 0 ;
75677
75678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75679   arg2 = (Dali::Actor *)jarg2;
75680   if (!arg2) {
75681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75682     return ;
75683   }
75684   {
75685     try {
75686       (arg1)->ScrollTo(*arg2);
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75694       };
75695     } catch (...) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75698       };
75699     }
75700   }
75701 }
75702
75703
75704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75706   Dali::Actor *arg2 = 0 ;
75707   float arg3 ;
75708
75709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75710   arg2 = (Dali::Actor *)jarg2;
75711   if (!arg2) {
75712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75713     return ;
75714   }
75715   arg3 = (float)jarg3;
75716   {
75717     try {
75718       (arg1)->ScrollTo(*arg2,arg3);
75719     } catch (std::out_of_range& e) {
75720       {
75721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75722       };
75723     } catch (std::exception& e) {
75724       {
75725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75726       };
75727     } catch (...) {
75728       {
75729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75730       };
75731     }
75732   }
75733 }
75734
75735
75736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75737   unsigned int jresult ;
75738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75739   bool result;
75740
75741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75742   {
75743     try {
75744       result = (bool)(arg1)->ScrollToSnapPoint();
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (...) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75756       };
75757     }
75758   }
75759   jresult = result;
75760   return jresult;
75761 }
75762
75763
75764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75766   Dali::Constraint arg2 ;
75767   Dali::Constraint *argp2 ;
75768
75769   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75770   argp2 = (Dali::Constraint *)jarg2;
75771   if (!argp2) {
75772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75773     return ;
75774   }
75775   arg2 = *argp2;
75776   {
75777     try {
75778       (arg1)->ApplyConstraintToChildren(arg2);
75779     } catch (std::out_of_range& e) {
75780       {
75781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75782       };
75783     } catch (std::exception& e) {
75784       {
75785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75786       };
75787     } catch (...) {
75788       {
75789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75790       };
75791     }
75792   }
75793 }
75794
75795
75796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75798
75799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75800   {
75801     try {
75802       (arg1)->RemoveConstraintsFromChildren();
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75810       };
75811     } catch (...) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75814       };
75815     }
75816   }
75817 }
75818
75819
75820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75822   Dali::Toolkit::ScrollViewEffect arg2 ;
75823   Dali::Toolkit::ScrollViewEffect *argp2 ;
75824
75825   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75826   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75827   if (!argp2) {
75828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75829     return ;
75830   }
75831   arg2 = *argp2;
75832   {
75833     try {
75834       (arg1)->ApplyEffect(arg2);
75835     } catch (std::out_of_range& e) {
75836       {
75837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75838       };
75839     } catch (std::exception& e) {
75840       {
75841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75842       };
75843     } catch (...) {
75844       {
75845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75846       };
75847     }
75848   }
75849 }
75850
75851
75852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75854   Dali::Toolkit::ScrollViewEffect arg2 ;
75855   Dali::Toolkit::ScrollViewEffect *argp2 ;
75856
75857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75858   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75859   if (!argp2) {
75860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75861     return ;
75862   }
75863   arg2 = *argp2;
75864   {
75865     try {
75866       (arg1)->RemoveEffect(arg2);
75867     } catch (std::out_of_range& e) {
75868       {
75869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75870       };
75871     } catch (std::exception& e) {
75872       {
75873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75874       };
75875     } catch (...) {
75876       {
75877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75878       };
75879     }
75880   }
75881 }
75882
75883
75884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
75885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75886
75887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75888   {
75889     try {
75890       (arg1)->RemoveAllEffects();
75891     } catch (std::out_of_range& e) {
75892       {
75893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (std::exception& e) {
75896       {
75897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75898       };
75899     } catch (...) {
75900       {
75901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75902       };
75903     }
75904   }
75905 }
75906
75907
75908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
75909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75910   Dali::Actor arg2 ;
75911   Dali::Actor *argp2 ;
75912
75913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75914   argp2 = (Dali::Actor *)jarg2;
75915   if (!argp2) {
75916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75917     return ;
75918   }
75919   arg2 = *argp2;
75920   {
75921     try {
75922       (arg1)->BindActor(arg2);
75923     } catch (std::out_of_range& e) {
75924       {
75925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75926       };
75927     } catch (std::exception& e) {
75928       {
75929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75930       };
75931     } catch (...) {
75932       {
75933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75934       };
75935     }
75936   }
75937 }
75938
75939
75940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
75941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75942   Dali::Actor arg2 ;
75943   Dali::Actor *argp2 ;
75944
75945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75946   argp2 = (Dali::Actor *)jarg2;
75947   if (!argp2) {
75948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75949     return ;
75950   }
75951   arg2 = *argp2;
75952   {
75953     try {
75954       (arg1)->UnbindActor(arg2);
75955     } catch (std::out_of_range& e) {
75956       {
75957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75958       };
75959     } catch (std::exception& e) {
75960       {
75961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75962       };
75963     } catch (...) {
75964       {
75965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75966       };
75967     }
75968   }
75969 }
75970
75971
75972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75974   Dali::Radian arg2 ;
75975   Dali::Radian arg3 ;
75976   Dali::Radian *argp2 ;
75977   Dali::Radian *argp3 ;
75978
75979   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75980   argp2 = (Dali::Radian *)jarg2;
75981   if (!argp2) {
75982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75983     return ;
75984   }
75985   arg2 = *argp2;
75986   argp3 = (Dali::Radian *)jarg3;
75987   if (!argp3) {
75988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75989     return ;
75990   }
75991   arg3 = *argp3;
75992   {
75993     try {
75994       (arg1)->SetScrollingDirection(arg2,arg3);
75995     } catch (std::out_of_range& e) {
75996       {
75997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75998       };
75999     } catch (std::exception& e) {
76000       {
76001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76002       };
76003     } catch (...) {
76004       {
76005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76006       };
76007     }
76008   }
76009 }
76010
76011
76012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76013   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76014   Dali::Radian arg2 ;
76015   Dali::Radian *argp2 ;
76016
76017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76018   argp2 = (Dali::Radian *)jarg2;
76019   if (!argp2) {
76020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76021     return ;
76022   }
76023   arg2 = *argp2;
76024   {
76025     try {
76026       (arg1)->SetScrollingDirection(arg2);
76027     } catch (std::out_of_range& e) {
76028       {
76029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76030       };
76031     } catch (std::exception& e) {
76032       {
76033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76034       };
76035     } catch (...) {
76036       {
76037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76038       };
76039     }
76040   }
76041 }
76042
76043
76044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76046   Dali::Radian arg2 ;
76047   Dali::Radian *argp2 ;
76048
76049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76050   argp2 = (Dali::Radian *)jarg2;
76051   if (!argp2) {
76052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76053     return ;
76054   }
76055   arg2 = *argp2;
76056   {
76057     try {
76058       (arg1)->RemoveScrollingDirection(arg2);
76059     } catch (std::out_of_range& e) {
76060       {
76061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76062       };
76063     } catch (std::exception& e) {
76064       {
76065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76066       };
76067     } catch (...) {
76068       {
76069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76070       };
76071     }
76072   }
76073 }
76074
76075
76076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76077   void * jresult ;
76078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76079   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76080
76081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76082   {
76083     try {
76084       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76085     } catch (std::out_of_range& e) {
76086       {
76087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (std::exception& e) {
76090       {
76091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76092       };
76093     } catch (...) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76096       };
76097     }
76098   }
76099   jresult = (void *)result;
76100   return jresult;
76101 }
76102
76103
76104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76105   int jresult ;
76106   int result;
76107
76108   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76109   jresult = (int)result;
76110   return jresult;
76111 }
76112
76113
76114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76115   int jresult ;
76116   int result;
76117
76118   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76119   jresult = (int)result;
76120   return jresult;
76121 }
76122
76123
76124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76125   int jresult ;
76126   int result;
76127
76128   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76129   jresult = (int)result;
76130   return jresult;
76131 }
76132
76133
76134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76135   int jresult ;
76136   int result;
76137
76138   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76139   jresult = (int)result;
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76145   int jresult ;
76146   int result;
76147
76148   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76149   jresult = (int)result;
76150   return jresult;
76151 }
76152
76153
76154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76155   void * jresult ;
76156   Dali::Toolkit::TableView::Property *result = 0 ;
76157
76158   {
76159     try {
76160       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76172       };
76173     }
76174   }
76175   jresult = (void *)result;
76176   return jresult;
76177 }
76178
76179
76180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76181   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76182
76183   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76184   {
76185     try {
76186       delete arg1;
76187     } catch (std::out_of_range& e) {
76188       {
76189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76190       };
76191     } catch (std::exception& e) {
76192       {
76193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76194       };
76195     } catch (...) {
76196       {
76197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76198       };
76199     }
76200   }
76201 }
76202
76203
76204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76205   int jresult ;
76206   int result;
76207
76208   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76209   jresult = (int)result;
76210   return jresult;
76211 }
76212
76213
76214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76215   int jresult ;
76216   int result;
76217
76218   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76219   jresult = (int)result;
76220   return jresult;
76221 }
76222
76223
76224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76225   int jresult ;
76226   int result;
76227
76228   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76229   jresult = (int)result;
76230   return jresult;
76231 }
76232
76233
76234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76235   int jresult ;
76236   int result;
76237
76238   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76239   jresult = (int)result;
76240   return jresult;
76241 }
76242
76243
76244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76245   int jresult ;
76246   int result;
76247
76248   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76249   jresult = (int)result;
76250   return jresult;
76251 }
76252
76253
76254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76255   void * jresult ;
76256   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76257
76258   {
76259     try {
76260       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76261     } catch (std::out_of_range& e) {
76262       {
76263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76264       };
76265     } catch (std::exception& e) {
76266       {
76267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76268       };
76269     } catch (...) {
76270       {
76271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76272       };
76273     }
76274   }
76275   jresult = (void *)result;
76276   return jresult;
76277 }
76278
76279
76280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76281   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76282
76283   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76284   {
76285     try {
76286       delete arg1;
76287     } catch (std::out_of_range& e) {
76288       {
76289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76290       };
76291     } catch (std::exception& e) {
76292       {
76293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (...) {
76296       {
76297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76298       };
76299     }
76300   }
76301 }
76302
76303
76304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76305   void * jresult ;
76306   unsigned int arg1 ;
76307   unsigned int arg2 ;
76308   unsigned int arg3 ;
76309   unsigned int arg4 ;
76310   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76311
76312   arg1 = (unsigned int)jarg1;
76313   arg2 = (unsigned int)jarg2;
76314   arg3 = (unsigned int)jarg3;
76315   arg4 = (unsigned int)jarg4;
76316   {
76317     try {
76318       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76319     } catch (std::out_of_range& e) {
76320       {
76321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (std::exception& e) {
76324       {
76325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76330       };
76331     }
76332   }
76333   jresult = (void *)result;
76334   return jresult;
76335 }
76336
76337
76338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76339   void * jresult ;
76340   unsigned int arg1 ;
76341   unsigned int arg2 ;
76342   unsigned int arg3 ;
76343   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76344
76345   arg1 = (unsigned int)jarg1;
76346   arg2 = (unsigned int)jarg2;
76347   arg3 = (unsigned int)jarg3;
76348   {
76349     try {
76350       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76351     } catch (std::out_of_range& e) {
76352       {
76353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76354       };
76355     } catch (std::exception& e) {
76356       {
76357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76358       };
76359     } catch (...) {
76360       {
76361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76362       };
76363     }
76364   }
76365   jresult = (void *)result;
76366   return jresult;
76367 }
76368
76369
76370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76371   void * jresult ;
76372   unsigned int arg1 ;
76373   unsigned int arg2 ;
76374   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76375
76376   arg1 = (unsigned int)jarg1;
76377   arg2 = (unsigned int)jarg2;
76378   {
76379     try {
76380       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76381     } catch (std::out_of_range& e) {
76382       {
76383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (std::exception& e) {
76386       {
76387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76388       };
76389     } catch (...) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76392       };
76393     }
76394   }
76395   jresult = (void *)result;
76396   return jresult;
76397 }
76398
76399
76400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76401   void * jresult ;
76402   unsigned int arg1 ;
76403   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76404
76405   arg1 = (unsigned int)jarg1;
76406   {
76407     try {
76408       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76409     } catch (std::out_of_range& e) {
76410       {
76411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76412       };
76413     } catch (std::exception& e) {
76414       {
76415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76416       };
76417     } catch (...) {
76418       {
76419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76420       };
76421     }
76422   }
76423   jresult = (void *)result;
76424   return jresult;
76425 }
76426
76427
76428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76429   void * jresult ;
76430   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76431
76432   {
76433     try {
76434       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (...) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76446       };
76447     }
76448   }
76449   jresult = (void *)result;
76450   return jresult;
76451 }
76452
76453
76454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76455   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76456   unsigned int arg2 ;
76457
76458   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76459   arg2 = (unsigned int)jarg2;
76460   if (arg1) (arg1)->rowIndex = arg2;
76461 }
76462
76463
76464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76465   unsigned int jresult ;
76466   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76467   unsigned int result;
76468
76469   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76470   result = (unsigned int) ((arg1)->rowIndex);
76471   jresult = result;
76472   return jresult;
76473 }
76474
76475
76476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76477   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76478   unsigned int arg2 ;
76479
76480   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76481   arg2 = (unsigned int)jarg2;
76482   if (arg1) (arg1)->columnIndex = arg2;
76483 }
76484
76485
76486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76487   unsigned int jresult ;
76488   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76489   unsigned int result;
76490
76491   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76492   result = (unsigned int) ((arg1)->columnIndex);
76493   jresult = result;
76494   return jresult;
76495 }
76496
76497
76498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76499   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76500   unsigned int arg2 ;
76501
76502   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76503   arg2 = (unsigned int)jarg2;
76504   if (arg1) (arg1)->rowSpan = arg2;
76505 }
76506
76507
76508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76509   unsigned int jresult ;
76510   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76511   unsigned int result;
76512
76513   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76514   result = (unsigned int) ((arg1)->rowSpan);
76515   jresult = result;
76516   return jresult;
76517 }
76518
76519
76520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76521   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76522   unsigned int arg2 ;
76523
76524   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76525   arg2 = (unsigned int)jarg2;
76526   if (arg1) (arg1)->columnSpan = arg2;
76527 }
76528
76529
76530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76531   unsigned int jresult ;
76532   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76533   unsigned int result;
76534
76535   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76536   result = (unsigned int) ((arg1)->columnSpan);
76537   jresult = result;
76538   return jresult;
76539 }
76540
76541
76542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76543   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76544
76545   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76546   {
76547     try {
76548       delete arg1;
76549     } catch (std::out_of_range& e) {
76550       {
76551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76552       };
76553     } catch (std::exception& e) {
76554       {
76555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76560       };
76561     }
76562   }
76563 }
76564
76565
76566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76567   void * jresult ;
76568   Dali::Toolkit::TableView *result = 0 ;
76569
76570   {
76571     try {
76572       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76573     } catch (std::out_of_range& e) {
76574       {
76575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76576       };
76577     } catch (std::exception& e) {
76578       {
76579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76580       };
76581     } catch (...) {
76582       {
76583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76584       };
76585     }
76586   }
76587   jresult = (void *)result;
76588   return jresult;
76589 }
76590
76591
76592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76593   void * jresult ;
76594   Dali::Toolkit::TableView *arg1 = 0 ;
76595   Dali::Toolkit::TableView *result = 0 ;
76596
76597   arg1 = (Dali::Toolkit::TableView *)jarg1;
76598   if (!arg1) {
76599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76600     return 0;
76601   }
76602   {
76603     try {
76604       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76605     } catch (std::out_of_range& e) {
76606       {
76607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76608       };
76609     } catch (std::exception& e) {
76610       {
76611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76612       };
76613     } catch (...) {
76614       {
76615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76616       };
76617     }
76618   }
76619   jresult = (void *)result;
76620   return jresult;
76621 }
76622
76623
76624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76625   void * jresult ;
76626   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76627   Dali::Toolkit::TableView *arg2 = 0 ;
76628   Dali::Toolkit::TableView *result = 0 ;
76629
76630   arg1 = (Dali::Toolkit::TableView *)jarg1;
76631   arg2 = (Dali::Toolkit::TableView *)jarg2;
76632   if (!arg2) {
76633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76634     return 0;
76635   }
76636   {
76637     try {
76638       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76639     } catch (std::out_of_range& e) {
76640       {
76641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76642       };
76643     } catch (std::exception& e) {
76644       {
76645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76646       };
76647     } catch (...) {
76648       {
76649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76650       };
76651     }
76652   }
76653   jresult = (void *)result;
76654   return jresult;
76655 }
76656
76657
76658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76659   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76660
76661   arg1 = (Dali::Toolkit::TableView *)jarg1;
76662   {
76663     try {
76664       delete arg1;
76665     } catch (std::out_of_range& e) {
76666       {
76667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76668       };
76669     } catch (std::exception& e) {
76670       {
76671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76672       };
76673     } catch (...) {
76674       {
76675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76676       };
76677     }
76678   }
76679 }
76680
76681
76682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76683   void * jresult ;
76684   unsigned int arg1 ;
76685   unsigned int arg2 ;
76686   Dali::Toolkit::TableView result;
76687
76688   arg1 = (unsigned int)jarg1;
76689   arg2 = (unsigned int)jarg2;
76690   {
76691     try {
76692       result = Dali::Toolkit::TableView::New(arg1,arg2);
76693     } catch (std::out_of_range& e) {
76694       {
76695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76696       };
76697     } catch (std::exception& e) {
76698       {
76699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76700       };
76701     } catch (...) {
76702       {
76703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76704       };
76705     }
76706   }
76707   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76713   void * jresult ;
76714   Dali::BaseHandle arg1 ;
76715   Dali::BaseHandle *argp1 ;
76716   Dali::Toolkit::TableView result;
76717
76718   argp1 = (Dali::BaseHandle *)jarg1;
76719   if (!argp1) {
76720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76721     return 0;
76722   }
76723   arg1 = *argp1;
76724   {
76725     try {
76726       result = Dali::Toolkit::TableView::DownCast(arg1);
76727     } catch (std::out_of_range& e) {
76728       {
76729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76730       };
76731     } catch (std::exception& e) {
76732       {
76733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76734       };
76735     } catch (...) {
76736       {
76737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76738       };
76739     }
76740   }
76741   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76742   return jresult;
76743 }
76744
76745
76746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76747   unsigned int jresult ;
76748   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76749   Dali::Actor arg2 ;
76750   Dali::Toolkit::TableView::CellPosition arg3 ;
76751   Dali::Actor *argp2 ;
76752   Dali::Toolkit::TableView::CellPosition *argp3 ;
76753   bool result;
76754
76755   arg1 = (Dali::Toolkit::TableView *)jarg1;
76756   argp2 = (Dali::Actor *)jarg2;
76757   if (!argp2) {
76758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76759     return 0;
76760   }
76761   arg2 = *argp2;
76762   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76763   if (!argp3) {
76764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76765     return 0;
76766   }
76767   arg3 = *argp3;
76768   {
76769     try {
76770       result = (bool)(arg1)->AddChild(arg2,arg3);
76771     } catch (std::out_of_range& e) {
76772       {
76773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76774       };
76775     } catch (std::exception& e) {
76776       {
76777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76778       };
76779     } catch (...) {
76780       {
76781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76782       };
76783     }
76784   }
76785   jresult = result;
76786   return jresult;
76787 }
76788
76789
76790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76791   void * jresult ;
76792   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76793   Dali::Toolkit::TableView::CellPosition arg2 ;
76794   Dali::Toolkit::TableView::CellPosition *argp2 ;
76795   Dali::Actor result;
76796
76797   arg1 = (Dali::Toolkit::TableView *)jarg1;
76798   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76799   if (!argp2) {
76800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76801     return 0;
76802   }
76803   arg2 = *argp2;
76804   {
76805     try {
76806       result = (arg1)->GetChildAt(arg2);
76807     } catch (std::out_of_range& e) {
76808       {
76809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76810       };
76811     } catch (std::exception& e) {
76812       {
76813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76814       };
76815     } catch (...) {
76816       {
76817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76818       };
76819     }
76820   }
76821   jresult = new Dali::Actor((const Dali::Actor &)result);
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76827   void * jresult ;
76828   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76829   Dali::Toolkit::TableView::CellPosition arg2 ;
76830   Dali::Toolkit::TableView::CellPosition *argp2 ;
76831   Dali::Actor result;
76832
76833   arg1 = (Dali::Toolkit::TableView *)jarg1;
76834   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76835   if (!argp2) {
76836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76837     return 0;
76838   }
76839   arg2 = *argp2;
76840   {
76841     try {
76842       result = (arg1)->RemoveChildAt(arg2);
76843     } catch (std::out_of_range& e) {
76844       {
76845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76846       };
76847     } catch (std::exception& e) {
76848       {
76849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76850       };
76851     } catch (...) {
76852       {
76853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76854       };
76855     }
76856   }
76857   jresult = new Dali::Actor((const Dali::Actor &)result);
76858   return jresult;
76859 }
76860
76861
76862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76863   unsigned int jresult ;
76864   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76865   Dali::Actor arg2 ;
76866   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
76867   Dali::Actor *argp2 ;
76868   bool result;
76869
76870   arg1 = (Dali::Toolkit::TableView *)jarg1;
76871   argp2 = (Dali::Actor *)jarg2;
76872   if (!argp2) {
76873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76874     return 0;
76875   }
76876   arg2 = *argp2;
76877   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76878   if (!arg3) {
76879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
76880     return 0;
76881   }
76882   {
76883     try {
76884       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
76885     } catch (std::out_of_range& e) {
76886       {
76887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76888       };
76889     } catch (std::exception& e) {
76890       {
76891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76892       };
76893     } catch (...) {
76894       {
76895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76896       };
76897     }
76898   }
76899   jresult = result;
76900   return jresult;
76901 }
76902
76903
76904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
76905   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76906   unsigned int arg2 ;
76907
76908   arg1 = (Dali::Toolkit::TableView *)jarg1;
76909   arg2 = (unsigned int)jarg2;
76910   {
76911     try {
76912       (arg1)->InsertRow(arg2);
76913     } catch (std::out_of_range& e) {
76914       {
76915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76916       };
76917     } catch (std::exception& e) {
76918       {
76919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (...) {
76922       {
76923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76924       };
76925     }
76926   }
76927 }
76928
76929
76930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
76931   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76932   unsigned int arg2 ;
76933
76934   arg1 = (Dali::Toolkit::TableView *)jarg1;
76935   arg2 = (unsigned int)jarg2;
76936   {
76937     try {
76938       (arg1)->DeleteRow(arg2);
76939     } catch (std::out_of_range& e) {
76940       {
76941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76942       };
76943     } catch (std::exception& e) {
76944       {
76945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76946       };
76947     } catch (...) {
76948       {
76949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76950       };
76951     }
76952   }
76953 }
76954
76955
76956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76957   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76958   unsigned int arg2 ;
76959   std::vector< Dali::Actor > *arg3 = 0 ;
76960
76961   arg1 = (Dali::Toolkit::TableView *)jarg1;
76962   arg2 = (unsigned int)jarg2;
76963   arg3 = (std::vector< Dali::Actor > *)jarg3;
76964   if (!arg3) {
76965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76966     return ;
76967   }
76968   {
76969     try {
76970       (arg1)->DeleteRow(arg2,*arg3);
76971     } catch (std::out_of_range& e) {
76972       {
76973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76974       };
76975     } catch (std::exception& e) {
76976       {
76977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76978       };
76979     } catch (...) {
76980       {
76981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76982       };
76983     }
76984   }
76985 }
76986
76987
76988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76989   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76990   unsigned int arg2 ;
76991
76992   arg1 = (Dali::Toolkit::TableView *)jarg1;
76993   arg2 = (unsigned int)jarg2;
76994   {
76995     try {
76996       (arg1)->InsertColumn(arg2);
76997     } catch (std::out_of_range& e) {
76998       {
76999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77000       };
77001     } catch (std::exception& e) {
77002       {
77003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77004       };
77005     } catch (...) {
77006       {
77007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77008       };
77009     }
77010   }
77011 }
77012
77013
77014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77015   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77016   unsigned int arg2 ;
77017
77018   arg1 = (Dali::Toolkit::TableView *)jarg1;
77019   arg2 = (unsigned int)jarg2;
77020   {
77021     try {
77022       (arg1)->DeleteColumn(arg2);
77023     } catch (std::out_of_range& e) {
77024       {
77025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77026       };
77027     } catch (std::exception& e) {
77028       {
77029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77030       };
77031     } catch (...) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77034       };
77035     }
77036   }
77037 }
77038
77039
77040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77041   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77042   unsigned int arg2 ;
77043   std::vector< Dali::Actor > *arg3 = 0 ;
77044
77045   arg1 = (Dali::Toolkit::TableView *)jarg1;
77046   arg2 = (unsigned int)jarg2;
77047   arg3 = (std::vector< Dali::Actor > *)jarg3;
77048   if (!arg3) {
77049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77050     return ;
77051   }
77052   {
77053     try {
77054       (arg1)->DeleteColumn(arg2,*arg3);
77055     } catch (std::out_of_range& e) {
77056       {
77057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77058       };
77059     } catch (std::exception& e) {
77060       {
77061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77062       };
77063     } catch (...) {
77064       {
77065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77066       };
77067     }
77068   }
77069 }
77070
77071
77072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77074   unsigned int arg2 ;
77075   unsigned int arg3 ;
77076
77077   arg1 = (Dali::Toolkit::TableView *)jarg1;
77078   arg2 = (unsigned int)jarg2;
77079   arg3 = (unsigned int)jarg3;
77080   {
77081     try {
77082       (arg1)->Resize(arg2,arg3);
77083     } catch (std::out_of_range& e) {
77084       {
77085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77086       };
77087     } catch (std::exception& e) {
77088       {
77089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77090       };
77091     } catch (...) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77094       };
77095     }
77096   }
77097 }
77098
77099
77100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77101   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77102   unsigned int arg2 ;
77103   unsigned int arg3 ;
77104   std::vector< Dali::Actor > *arg4 = 0 ;
77105
77106   arg1 = (Dali::Toolkit::TableView *)jarg1;
77107   arg2 = (unsigned int)jarg2;
77108   arg3 = (unsigned int)jarg3;
77109   arg4 = (std::vector< Dali::Actor > *)jarg4;
77110   if (!arg4) {
77111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77112     return ;
77113   }
77114   {
77115     try {
77116       (arg1)->Resize(arg2,arg3,*arg4);
77117     } catch (std::out_of_range& e) {
77118       {
77119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77120       };
77121     } catch (std::exception& e) {
77122       {
77123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77124       };
77125     } catch (...) {
77126       {
77127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77128       };
77129     }
77130   }
77131 }
77132
77133
77134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77135   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77136   Dali::Size arg2 ;
77137   Dali::Size *argp2 ;
77138
77139   arg1 = (Dali::Toolkit::TableView *)jarg1;
77140   argp2 = (Dali::Size *)jarg2;
77141   if (!argp2) {
77142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77143     return ;
77144   }
77145   arg2 = *argp2;
77146   {
77147     try {
77148       (arg1)->SetCellPadding(arg2);
77149     } catch (std::out_of_range& e) {
77150       {
77151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77152       };
77153     } catch (std::exception& e) {
77154       {
77155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77156       };
77157     } catch (...) {
77158       {
77159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77160       };
77161     }
77162   }
77163 }
77164
77165
77166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77167   void * jresult ;
77168   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77169   Dali::Size result;
77170
77171   arg1 = (Dali::Toolkit::TableView *)jarg1;
77172   {
77173     try {
77174       result = (arg1)->GetCellPadding();
77175     } catch (std::out_of_range& e) {
77176       {
77177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77178       };
77179     } catch (std::exception& e) {
77180       {
77181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (...) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77186       };
77187     }
77188   }
77189   jresult = new Dali::Size((const Dali::Size &)result);
77190   return jresult;
77191 }
77192
77193
77194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77195   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77196   unsigned int arg2 ;
77197
77198   arg1 = (Dali::Toolkit::TableView *)jarg1;
77199   arg2 = (unsigned int)jarg2;
77200   {
77201     try {
77202       (arg1)->SetFitHeight(arg2);
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77210       };
77211     } catch (...) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77214       };
77215     }
77216   }
77217 }
77218
77219
77220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77221   unsigned int jresult ;
77222   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77223   unsigned int arg2 ;
77224   bool result;
77225
77226   arg1 = (Dali::Toolkit::TableView *)jarg1;
77227   arg2 = (unsigned int)jarg2;
77228   {
77229     try {
77230       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77231     } catch (std::out_of_range& e) {
77232       {
77233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77234       };
77235     } catch (std::exception& e) {
77236       {
77237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (...) {
77240       {
77241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77242       };
77243     }
77244   }
77245   jresult = result;
77246   return jresult;
77247 }
77248
77249
77250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77251   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77252   unsigned int arg2 ;
77253
77254   arg1 = (Dali::Toolkit::TableView *)jarg1;
77255   arg2 = (unsigned int)jarg2;
77256   {
77257     try {
77258       (arg1)->SetFitWidth(arg2);
77259     } catch (std::out_of_range& e) {
77260       {
77261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77262       };
77263     } catch (std::exception& e) {
77264       {
77265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77266       };
77267     } catch (...) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77270       };
77271     }
77272   }
77273 }
77274
77275
77276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77277   unsigned int jresult ;
77278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77279   unsigned int arg2 ;
77280   bool result;
77281
77282   arg1 = (Dali::Toolkit::TableView *)jarg1;
77283   arg2 = (unsigned int)jarg2;
77284   {
77285     try {
77286       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77287     } catch (std::out_of_range& e) {
77288       {
77289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77290       };
77291     } catch (std::exception& e) {
77292       {
77293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77294       };
77295     } catch (...) {
77296       {
77297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77298       };
77299     }
77300   }
77301   jresult = result;
77302   return jresult;
77303 }
77304
77305
77306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77307   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77308   unsigned int arg2 ;
77309   float arg3 ;
77310
77311   arg1 = (Dali::Toolkit::TableView *)jarg1;
77312   arg2 = (unsigned int)jarg2;
77313   arg3 = (float)jarg3;
77314   {
77315     try {
77316       (arg1)->SetFixedHeight(arg2,arg3);
77317     } catch (std::out_of_range& e) {
77318       {
77319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77320       };
77321     } catch (std::exception& e) {
77322       {
77323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77324       };
77325     } catch (...) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77328       };
77329     }
77330   }
77331 }
77332
77333
77334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77335   float jresult ;
77336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77337   unsigned int arg2 ;
77338   float result;
77339
77340   arg1 = (Dali::Toolkit::TableView *)jarg1;
77341   arg2 = (unsigned int)jarg2;
77342   {
77343     try {
77344       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77345     } catch (std::out_of_range& e) {
77346       {
77347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (std::exception& e) {
77350       {
77351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77356       };
77357     }
77358   }
77359   jresult = result;
77360   return jresult;
77361 }
77362
77363
77364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77366   unsigned int arg2 ;
77367   float arg3 ;
77368
77369   arg1 = (Dali::Toolkit::TableView *)jarg1;
77370   arg2 = (unsigned int)jarg2;
77371   arg3 = (float)jarg3;
77372   {
77373     try {
77374       (arg1)->SetRelativeHeight(arg2,arg3);
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77382       };
77383     } catch (...) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77386       };
77387     }
77388   }
77389 }
77390
77391
77392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77393   float jresult ;
77394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77395   unsigned int arg2 ;
77396   float result;
77397
77398   arg1 = (Dali::Toolkit::TableView *)jarg1;
77399   arg2 = (unsigned int)jarg2;
77400   {
77401     try {
77402       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77403     } catch (std::out_of_range& e) {
77404       {
77405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77406       };
77407     } catch (std::exception& e) {
77408       {
77409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77410       };
77411     } catch (...) {
77412       {
77413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77414       };
77415     }
77416   }
77417   jresult = result;
77418   return jresult;
77419 }
77420
77421
77422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77423   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77424   unsigned int arg2 ;
77425   float arg3 ;
77426
77427   arg1 = (Dali::Toolkit::TableView *)jarg1;
77428   arg2 = (unsigned int)jarg2;
77429   arg3 = (float)jarg3;
77430   {
77431     try {
77432       (arg1)->SetFixedWidth(arg2,arg3);
77433     } catch (std::out_of_range& e) {
77434       {
77435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77436       };
77437     } catch (std::exception& e) {
77438       {
77439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77440       };
77441     } catch (...) {
77442       {
77443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77444       };
77445     }
77446   }
77447 }
77448
77449
77450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77451   float jresult ;
77452   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77453   unsigned int arg2 ;
77454   float result;
77455
77456   arg1 = (Dali::Toolkit::TableView *)jarg1;
77457   arg2 = (unsigned int)jarg2;
77458   {
77459     try {
77460       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77461     } catch (std::out_of_range& e) {
77462       {
77463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77464       };
77465     } catch (std::exception& e) {
77466       {
77467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77468       };
77469     } catch (...) {
77470       {
77471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77472       };
77473     }
77474   }
77475   jresult = result;
77476   return jresult;
77477 }
77478
77479
77480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77481   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77482   unsigned int arg2 ;
77483   float arg3 ;
77484
77485   arg1 = (Dali::Toolkit::TableView *)jarg1;
77486   arg2 = (unsigned int)jarg2;
77487   arg3 = (float)jarg3;
77488   {
77489     try {
77490       (arg1)->SetRelativeWidth(arg2,arg3);
77491     } catch (std::out_of_range& e) {
77492       {
77493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77494       };
77495     } catch (std::exception& e) {
77496       {
77497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77498       };
77499     } catch (...) {
77500       {
77501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77502       };
77503     }
77504   }
77505 }
77506
77507
77508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77509   float jresult ;
77510   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77511   unsigned int arg2 ;
77512   float result;
77513
77514   arg1 = (Dali::Toolkit::TableView *)jarg1;
77515   arg2 = (unsigned int)jarg2;
77516   {
77517     try {
77518       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77519     } catch (std::out_of_range& e) {
77520       {
77521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (std::exception& e) {
77524       {
77525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (...) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77530       };
77531     }
77532   }
77533   jresult = result;
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77539   unsigned int jresult ;
77540   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77541   unsigned int result;
77542
77543   arg1 = (Dali::Toolkit::TableView *)jarg1;
77544   {
77545     try {
77546       result = (unsigned int)(arg1)->GetRows();
77547     } catch (std::out_of_range& e) {
77548       {
77549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77550       };
77551     } catch (std::exception& e) {
77552       {
77553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77554       };
77555     } catch (...) {
77556       {
77557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77558       };
77559     }
77560   }
77561   jresult = result;
77562   return jresult;
77563 }
77564
77565
77566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77567   unsigned int jresult ;
77568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77569   unsigned int result;
77570
77571   arg1 = (Dali::Toolkit::TableView *)jarg1;
77572   {
77573     try {
77574       result = (unsigned int)(arg1)->GetColumns();
77575     } catch (std::out_of_range& e) {
77576       {
77577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77578       };
77579     } catch (std::exception& e) {
77580       {
77581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77582       };
77583     } catch (...) {
77584       {
77585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77586       };
77587     }
77588   }
77589   jresult = result;
77590   return jresult;
77591 }
77592
77593
77594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77595   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77596   Dali::Toolkit::TableView::CellPosition arg2 ;
77597   Dali::HorizontalAlignment::Type arg3 ;
77598   Dali::VerticalAlignment::Type arg4 ;
77599   Dali::Toolkit::TableView::CellPosition *argp2 ;
77600
77601   arg1 = (Dali::Toolkit::TableView *)jarg1;
77602   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77603   if (!argp2) {
77604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77605     return ;
77606   }
77607   arg2 = *argp2;
77608   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77609   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77610   {
77611     try {
77612       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77613     } catch (std::out_of_range& e) {
77614       {
77615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77616       };
77617     } catch (std::exception& e) {
77618       {
77619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77620       };
77621     } catch (...) {
77622       {
77623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77624       };
77625     }
77626   }
77627 }
77628
77629
77630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77631   unsigned int jresult ;
77632   unsigned int result;
77633
77634   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77635   jresult = result;
77636   return jresult;
77637 }
77638
77639
77640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77641   int jresult ;
77642   int result;
77643
77644   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77645   jresult = (int)result;
77646   return jresult;
77647 }
77648
77649
77650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77651   int jresult ;
77652   int result;
77653
77654   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77655   jresult = (int)result;
77656   return jresult;
77657 }
77658
77659
77660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77661   int jresult ;
77662   int result;
77663
77664   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77665   jresult = (int)result;
77666   return jresult;
77667 }
77668
77669
77670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77671   int jresult ;
77672   int result;
77673
77674   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77675   jresult = (int)result;
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77681   int jresult ;
77682   int result;
77683
77684   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77685   jresult = (int)result;
77686   return jresult;
77687 }
77688
77689
77690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77691   int jresult ;
77692   int result;
77693
77694   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77695   jresult = (int)result;
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77701   int jresult ;
77702   int result;
77703
77704   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77705   jresult = (int)result;
77706   return jresult;
77707 }
77708
77709
77710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77711   int jresult ;
77712   int result;
77713
77714   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77715   jresult = (int)result;
77716   return jresult;
77717 }
77718
77719
77720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77721   int jresult ;
77722   int result;
77723
77724   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77725   jresult = (int)result;
77726   return jresult;
77727 }
77728
77729
77730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77731   int jresult ;
77732   int result;
77733
77734   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77735   jresult = (int)result;
77736   return jresult;
77737 }
77738
77739
77740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77741   int jresult ;
77742   int result;
77743
77744   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77745   jresult = (int)result;
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77751   int jresult ;
77752   int result;
77753
77754   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77755   jresult = (int)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77761   int jresult ;
77762   int result;
77763
77764   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77765   jresult = (int)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77771   int jresult ;
77772   int result;
77773
77774   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77775   jresult = (int)result;
77776   return jresult;
77777 }
77778
77779
77780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77781   int jresult ;
77782   int result;
77783
77784   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77785   jresult = (int)result;
77786   return jresult;
77787 }
77788
77789
77790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77791   int jresult ;
77792   int result;
77793
77794   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77795   jresult = (int)result;
77796   return jresult;
77797 }
77798
77799
77800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77801   int jresult ;
77802   int result;
77803
77804   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77805   jresult = (int)result;
77806   return jresult;
77807 }
77808
77809
77810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77811   int jresult ;
77812   int result;
77813
77814   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77815   jresult = (int)result;
77816   return jresult;
77817 }
77818
77819
77820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77821   int jresult ;
77822   int result;
77823
77824   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77825   jresult = (int)result;
77826   return jresult;
77827 }
77828
77829
77830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77831   int jresult ;
77832   int result;
77833
77834   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77835   jresult = (int)result;
77836   return jresult;
77837 }
77838
77839
77840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77841   int jresult ;
77842   int result;
77843
77844   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77845   jresult = (int)result;
77846   return jresult;
77847 }
77848
77849
77850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77851   int jresult ;
77852   int result;
77853
77854   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77855   jresult = (int)result;
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77861   int jresult ;
77862   int result;
77863
77864   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77865   jresult = (int)result;
77866   return jresult;
77867 }
77868
77869
77870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77871   int jresult ;
77872   int result;
77873
77874   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
77875   jresult = (int)result;
77876   return jresult;
77877 }
77878
77879
77880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
77881   int jresult ;
77882   int result;
77883
77884   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
77885   jresult = (int)result;
77886   return jresult;
77887 }
77888
77889
77890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
77891   int jresult ;
77892   int result;
77893
77894   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
77895   jresult = (int)result;
77896   return jresult;
77897 }
77898
77899
77900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
77901   int jresult ;
77902   int result;
77903
77904   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
77905   jresult = (int)result;
77906   return jresult;
77907 }
77908
77909
77910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
77911   int jresult ;
77912   int result;
77913
77914   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
77915   jresult = (int)result;
77916   return jresult;
77917 }
77918
77919
77920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
77921   int jresult ;
77922   int result;
77923
77924   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
77925   jresult = (int)result;
77926   return jresult;
77927 }
77928
77929
77930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
77931   int jresult ;
77932   int result;
77933
77934   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
77935   jresult = (int)result;
77936   return jresult;
77937 }
77938
77939
77940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
77941   int jresult ;
77942   int result;
77943
77944   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
77945   jresult = (int)result;
77946   return jresult;
77947 }
77948
77949
77950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
77951   int jresult ;
77952   int result;
77953
77954   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
77955   jresult = (int)result;
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
77961   int jresult ;
77962   int result;
77963
77964   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
77965   jresult = (int)result;
77966   return jresult;
77967 }
77968
77969
77970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77971   int jresult ;
77972   int result;
77973
77974   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77975   jresult = (int)result;
77976   return jresult;
77977 }
77978
77979
77980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77981   int jresult ;
77982   int result;
77983
77984   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77985   jresult = (int)result;
77986   return jresult;
77987 }
77988
77989
77990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77991   int jresult ;
77992   int result;
77993
77994   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77995   jresult = (int)result;
77996   return jresult;
77997 }
77998
77999
78000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78001   int jresult ;
78002   int result;
78003
78004   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78005   jresult = (int)result;
78006   return jresult;
78007 }
78008
78009
78010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78011   int jresult ;
78012   int result;
78013
78014   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78015   jresult = (int)result;
78016   return jresult;
78017 }
78018
78019
78020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78021   int jresult ;
78022   int result;
78023
78024   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78025   jresult = (int)result;
78026   return jresult;
78027 }
78028
78029
78030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78031   int jresult ;
78032   int result;
78033
78034   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78035   jresult = (int)result;
78036   return jresult;
78037 }
78038
78039
78040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78041   void * jresult ;
78042   Dali::Toolkit::TextEditor::Property *result = 0 ;
78043
78044   {
78045     try {
78046       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78047     } catch (std::out_of_range& e) {
78048       {
78049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (std::exception& e) {
78052       {
78053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061   jresult = (void *)result;
78062   return jresult;
78063 }
78064
78065
78066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78067   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78068
78069   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78070   {
78071     try {
78072       delete arg1;
78073     } catch (std::out_of_range& e) {
78074       {
78075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78076       };
78077     } catch (std::exception& e) {
78078       {
78079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78080       };
78081     } catch (...) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78084       };
78085     }
78086   }
78087 }
78088
78089
78090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78091   void * jresult ;
78092   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78093
78094   {
78095     try {
78096       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78097     } catch (std::out_of_range& e) {
78098       {
78099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78100       };
78101     } catch (std::exception& e) {
78102       {
78103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78104       };
78105     } catch (...) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78108       };
78109     }
78110   }
78111   jresult = (void *)result;
78112   return jresult;
78113 }
78114
78115
78116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78117   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78118
78119   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78120   {
78121     try {
78122       delete arg1;
78123     } catch (std::out_of_range& e) {
78124       {
78125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78126       };
78127     } catch (std::exception& e) {
78128       {
78129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78130       };
78131     } catch (...) {
78132       {
78133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78134       };
78135     }
78136   }
78137 }
78138
78139
78140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78141   void * jresult ;
78142   Dali::Toolkit::TextEditor result;
78143
78144   {
78145     try {
78146       result = Dali::Toolkit::TextEditor::New();
78147     } catch (std::out_of_range& e) {
78148       {
78149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78150       };
78151     } catch (std::exception& e) {
78152       {
78153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78154       };
78155     } catch (...) {
78156       {
78157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78158       };
78159     }
78160   }
78161   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78162   return jresult;
78163 }
78164
78165
78166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78167   void * jresult ;
78168   Dali::Toolkit::TextEditor *result = 0 ;
78169
78170   {
78171     try {
78172       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78173     } catch (std::out_of_range& e) {
78174       {
78175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78176       };
78177     } catch (std::exception& e) {
78178       {
78179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78180       };
78181     } catch (...) {
78182       {
78183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78184       };
78185     }
78186   }
78187   jresult = (void *)result;
78188   return jresult;
78189 }
78190
78191
78192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78193   void * jresult ;
78194   Dali::Toolkit::TextEditor *arg1 = 0 ;
78195   Dali::Toolkit::TextEditor *result = 0 ;
78196
78197   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78198   if (!arg1) {
78199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78200     return 0;
78201   }
78202   {
78203     try {
78204       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78205     } catch (std::out_of_range& e) {
78206       {
78207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78208       };
78209     } catch (std::exception& e) {
78210       {
78211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78212       };
78213     } catch (...) {
78214       {
78215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78216       };
78217     }
78218   }
78219   jresult = (void *)result;
78220   return jresult;
78221 }
78222
78223
78224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78225   void * jresult ;
78226   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78227   Dali::Toolkit::TextEditor *arg2 = 0 ;
78228   Dali::Toolkit::TextEditor *result = 0 ;
78229
78230   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78231   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78232   if (!arg2) {
78233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78234     return 0;
78235   }
78236   {
78237     try {
78238       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78239     } catch (std::out_of_range& e) {
78240       {
78241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78242       };
78243     } catch (std::exception& e) {
78244       {
78245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78246       };
78247     } catch (...) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78250       };
78251     }
78252   }
78253   jresult = (void *)result;
78254   return jresult;
78255 }
78256
78257
78258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78259   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78260
78261   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78262   {
78263     try {
78264       delete arg1;
78265     } catch (std::out_of_range& e) {
78266       {
78267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78268       };
78269     } catch (std::exception& e) {
78270       {
78271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78272       };
78273     } catch (...) {
78274       {
78275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78276       };
78277     }
78278   }
78279 }
78280
78281
78282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78283   void * jresult ;
78284   Dali::BaseHandle arg1 ;
78285   Dali::BaseHandle *argp1 ;
78286   Dali::Toolkit::TextEditor result;
78287
78288   argp1 = (Dali::BaseHandle *)jarg1;
78289   if (!argp1) {
78290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78291     return 0;
78292   }
78293   arg1 = *argp1;
78294   {
78295     try {
78296       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78297     } catch (std::out_of_range& e) {
78298       {
78299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78300       };
78301     } catch (std::exception& e) {
78302       {
78303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78304       };
78305     } catch (...) {
78306       {
78307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78308       };
78309     }
78310   }
78311   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78312   return jresult;
78313 }
78314
78315
78316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78317   void * jresult ;
78318   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78319   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78320
78321   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78322   {
78323     try {
78324       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78325     } catch (std::out_of_range& e) {
78326       {
78327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78328       };
78329     } catch (std::exception& e) {
78330       {
78331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78332       };
78333     } catch (...) {
78334       {
78335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78336       };
78337     }
78338   }
78339   jresult = (void *)result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78345   void * jresult ;
78346   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78347   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78348
78349   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78350   {
78351     try {
78352       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78353     } catch (std::out_of_range& e) {
78354       {
78355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78356       };
78357     } catch (std::exception& e) {
78358       {
78359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78360       };
78361     } catch (...) {
78362       {
78363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78364       };
78365     }
78366   }
78367   jresult = (void *)result;
78368   return jresult;
78369 }
78370
78371
78372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78373   int jresult ;
78374   int result;
78375
78376   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78377   jresult = (int)result;
78378   return jresult;
78379 }
78380
78381
78382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78383   int jresult ;
78384   int result;
78385
78386   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78387   jresult = (int)result;
78388   return jresult;
78389 }
78390
78391
78392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78393   int jresult ;
78394   int result;
78395
78396   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78397   jresult = (int)result;
78398   return jresult;
78399 }
78400
78401
78402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78403   int jresult ;
78404   int result;
78405
78406   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78407   jresult = (int)result;
78408   return jresult;
78409 }
78410
78411
78412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78413   int jresult ;
78414   int result;
78415
78416   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78417   jresult = (int)result;
78418   return jresult;
78419 }
78420
78421
78422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78423   int jresult ;
78424   int result;
78425
78426   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78427   jresult = (int)result;
78428   return jresult;
78429 }
78430
78431
78432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78433   int jresult ;
78434   int result;
78435
78436   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78437   jresult = (int)result;
78438   return jresult;
78439 }
78440
78441
78442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78443   int jresult ;
78444   int result;
78445
78446   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78447   jresult = (int)result;
78448   return jresult;
78449 }
78450
78451
78452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78453   int jresult ;
78454   int result;
78455
78456   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78457   jresult = (int)result;
78458   return jresult;
78459 }
78460
78461
78462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78463   int jresult ;
78464   int result;
78465
78466   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78467   jresult = (int)result;
78468   return jresult;
78469 }
78470
78471
78472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78473   int jresult ;
78474   int result;
78475
78476   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78477   jresult = (int)result;
78478   return jresult;
78479 }
78480
78481
78482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78483   int jresult ;
78484   int result;
78485
78486   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78487   jresult = (int)result;
78488   return jresult;
78489 }
78490
78491
78492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78493   int jresult ;
78494   int result;
78495
78496   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78497   jresult = (int)result;
78498   return jresult;
78499 }
78500
78501
78502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78503   int jresult ;
78504   int result;
78505
78506   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78507   jresult = (int)result;
78508   return jresult;
78509 }
78510
78511
78512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78513   int jresult ;
78514   int result;
78515
78516   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78517   jresult = (int)result;
78518   return jresult;
78519 }
78520
78521
78522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78523   int jresult ;
78524   int result;
78525
78526   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78527   jresult = (int)result;
78528   return jresult;
78529 }
78530
78531
78532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78533   int jresult ;
78534   int result;
78535
78536   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78537   jresult = (int)result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78543   int jresult ;
78544   int result;
78545
78546   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78547   jresult = (int)result;
78548   return jresult;
78549 }
78550
78551
78552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78553   int jresult ;
78554   int result;
78555
78556   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78557   jresult = (int)result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78563   int jresult ;
78564   int result;
78565
78566   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78567   jresult = (int)result;
78568   return jresult;
78569 }
78570
78571
78572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78573   int jresult ;
78574   int result;
78575
78576   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78577   jresult = (int)result;
78578   return jresult;
78579 }
78580
78581
78582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78583   int jresult ;
78584   int result;
78585
78586   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78587   jresult = (int)result;
78588   return jresult;
78589 }
78590
78591
78592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78593   int jresult ;
78594   int result;
78595
78596   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78597   jresult = (int)result;
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78603   int jresult ;
78604   int result;
78605
78606   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78607   jresult = (int)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78613   int jresult ;
78614   int result;
78615
78616   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78617   jresult = (int)result;
78618   return jresult;
78619 }
78620
78621
78622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78623   int jresult ;
78624   int result;
78625
78626   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78627   jresult = (int)result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78633   int jresult ;
78634   int result;
78635
78636   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78637   jresult = (int)result;
78638   return jresult;
78639 }
78640
78641
78642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78643   int jresult ;
78644   int result;
78645
78646   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78647   jresult = (int)result;
78648   return jresult;
78649 }
78650
78651
78652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78653   int jresult ;
78654   int result;
78655
78656   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78657   jresult = (int)result;
78658   return jresult;
78659 }
78660
78661
78662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78663   int jresult ;
78664   int result;
78665
78666   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78667   jresult = (int)result;
78668   return jresult;
78669 }
78670
78671
78672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78673   int jresult ;
78674   int result;
78675
78676   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78677   jresult = (int)result;
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78683   int jresult ;
78684   int result;
78685
78686   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78687   jresult = (int)result;
78688   return jresult;
78689 }
78690
78691
78692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78693   int jresult ;
78694   int result;
78695
78696   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78697   jresult = (int)result;
78698   return jresult;
78699 }
78700
78701
78702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78703   int jresult ;
78704   int result;
78705
78706   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78707   jresult = (int)result;
78708   return jresult;
78709 }
78710
78711
78712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78713   int jresult ;
78714   int result;
78715
78716   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78717   jresult = (int)result;
78718   return jresult;
78719 }
78720
78721
78722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78723   int jresult ;
78724   int result;
78725
78726   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78727   jresult = (int)result;
78728   return jresult;
78729 }
78730
78731
78732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78733   int jresult ;
78734   int result;
78735
78736   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78737   jresult = (int)result;
78738   return jresult;
78739 }
78740
78741
78742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78743   int jresult ;
78744   int result;
78745
78746   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78747   jresult = (int)result;
78748   return jresult;
78749 }
78750
78751
78752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78753   int jresult ;
78754   int result;
78755
78756   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78757   jresult = (int)result;
78758   return jresult;
78759 }
78760
78761
78762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78763   int jresult ;
78764   int result;
78765
78766   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78767   jresult = (int)result;
78768   return jresult;
78769 }
78770
78771
78772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78773   int jresult ;
78774   int result;
78775
78776   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78777   jresult = (int)result;
78778   return jresult;
78779 }
78780
78781
78782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78783   int jresult ;
78784   int result;
78785
78786   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78787   jresult = (int)result;
78788   return jresult;
78789 }
78790
78791
78792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78793   int jresult ;
78794   int result;
78795
78796   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78797   jresult = (int)result;
78798   return jresult;
78799 }
78800
78801
78802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78803   int jresult ;
78804   int result;
78805
78806   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78807   jresult = (int)result;
78808   return jresult;
78809 }
78810
78811
78812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78813   int jresult ;
78814   int result;
78815
78816   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78817   jresult = (int)result;
78818   return jresult;
78819 }
78820
78821
78822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78823   int jresult ;
78824   int result;
78825
78826   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78827   jresult = (int)result;
78828   return jresult;
78829 }
78830
78831
78832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78833   int jresult ;
78834   int result;
78835
78836   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78837   jresult = (int)result;
78838   return jresult;
78839 }
78840
78841
78842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78843   void * jresult ;
78844   Dali::Toolkit::TextField::Property *result = 0 ;
78845
78846   {
78847     try {
78848       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78849     } catch (std::out_of_range& e) {
78850       {
78851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78852       };
78853     } catch (std::exception& e) {
78854       {
78855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (...) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78860       };
78861     }
78862   }
78863   jresult = (void *)result;
78864   return jresult;
78865 }
78866
78867
78868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
78869   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
78870
78871   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
78872   {
78873     try {
78874       delete arg1;
78875     } catch (std::out_of_range& e) {
78876       {
78877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78878       };
78879     } catch (std::exception& e) {
78880       {
78881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78882       };
78883     } catch (...) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78886       };
78887     }
78888   }
78889 }
78890
78891
78892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
78893   void * jresult ;
78894   Dali::Toolkit::TextField::InputStyle *result = 0 ;
78895
78896   {
78897     try {
78898       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
78899     } catch (std::out_of_range& e) {
78900       {
78901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78902       };
78903     } catch (std::exception& e) {
78904       {
78905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78906       };
78907     } catch (...) {
78908       {
78909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78910       };
78911     }
78912   }
78913   jresult = (void *)result;
78914   return jresult;
78915 }
78916
78917
78918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
78919   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
78920
78921   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
78922   {
78923     try {
78924       delete arg1;
78925     } catch (std::out_of_range& e) {
78926       {
78927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78928       };
78929     } catch (std::exception& e) {
78930       {
78931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78932       };
78933     } catch (...) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78936       };
78937     }
78938   }
78939 }
78940
78941
78942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
78943   void * jresult ;
78944   Dali::Toolkit::TextField result;
78945
78946   {
78947     try {
78948       result = Dali::Toolkit::TextField::New();
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78956       };
78957     } catch (...) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78960       };
78961     }
78962   }
78963   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78964   return jresult;
78965 }
78966
78967
78968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78969   void * jresult ;
78970   Dali::Toolkit::TextField *result = 0 ;
78971
78972   {
78973     try {
78974       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78975     } catch (std::out_of_range& e) {
78976       {
78977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78978       };
78979     } catch (std::exception& e) {
78980       {
78981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78982       };
78983     } catch (...) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78986       };
78987     }
78988   }
78989   jresult = (void *)result;
78990   return jresult;
78991 }
78992
78993
78994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78995   void * jresult ;
78996   Dali::Toolkit::TextField *arg1 = 0 ;
78997   Dali::Toolkit::TextField *result = 0 ;
78998
78999   arg1 = (Dali::Toolkit::TextField *)jarg1;
79000   if (!arg1) {
79001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79002     return 0;
79003   }
79004   {
79005     try {
79006       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79007     } catch (std::out_of_range& e) {
79008       {
79009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79010       };
79011     } catch (std::exception& e) {
79012       {
79013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79014       };
79015     } catch (...) {
79016       {
79017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79018       };
79019     }
79020   }
79021   jresult = (void *)result;
79022   return jresult;
79023 }
79024
79025
79026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79027   void * jresult ;
79028   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79029   Dali::Toolkit::TextField *arg2 = 0 ;
79030   Dali::Toolkit::TextField *result = 0 ;
79031
79032   arg1 = (Dali::Toolkit::TextField *)jarg1;
79033   arg2 = (Dali::Toolkit::TextField *)jarg2;
79034   if (!arg2) {
79035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79036     return 0;
79037   }
79038   {
79039     try {
79040       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79052       };
79053     }
79054   }
79055   jresult = (void *)result;
79056   return jresult;
79057 }
79058
79059
79060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79061   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79062
79063   arg1 = (Dali::Toolkit::TextField *)jarg1;
79064   {
79065     try {
79066       delete arg1;
79067     } catch (std::out_of_range& e) {
79068       {
79069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79070       };
79071     } catch (std::exception& e) {
79072       {
79073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79074       };
79075     } catch (...) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79078       };
79079     }
79080   }
79081 }
79082
79083
79084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79085   void * jresult ;
79086   Dali::BaseHandle arg1 ;
79087   Dali::BaseHandle *argp1 ;
79088   Dali::Toolkit::TextField result;
79089
79090   argp1 = (Dali::BaseHandle *)jarg1;
79091   if (!argp1) {
79092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79093     return 0;
79094   }
79095   arg1 = *argp1;
79096   {
79097     try {
79098       result = Dali::Toolkit::TextField::DownCast(arg1);
79099     } catch (std::out_of_range& e) {
79100       {
79101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79102       };
79103     } catch (std::exception& e) {
79104       {
79105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79106       };
79107     } catch (...) {
79108       {
79109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79110       };
79111     }
79112   }
79113   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79114   return jresult;
79115 }
79116
79117
79118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79119   void * jresult ;
79120   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79121   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79122
79123   arg1 = (Dali::Toolkit::TextField *)jarg1;
79124   {
79125     try {
79126       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79127     } catch (std::out_of_range& e) {
79128       {
79129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (std::exception& e) {
79132       {
79133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (...) {
79136       {
79137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79138       };
79139     }
79140   }
79141   jresult = (void *)result;
79142   return jresult;
79143 }
79144
79145
79146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79147   void * jresult ;
79148   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79149   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79150
79151   arg1 = (Dali::Toolkit::TextField *)jarg1;
79152   {
79153     try {
79154       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79155     } catch (std::out_of_range& e) {
79156       {
79157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79158       };
79159     } catch (std::exception& e) {
79160       {
79161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (...) {
79164       {
79165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79166       };
79167     }
79168   }
79169   jresult = (void *)result;
79170   return jresult;
79171 }
79172
79173
79174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79175   void * jresult ;
79176   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79177   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79178
79179   arg1 = (Dali::Toolkit::TextField *)jarg1;
79180   {
79181     try {
79182       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79183     } catch (std::out_of_range& e) {
79184       {
79185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79186       };
79187     } catch (std::exception& e) {
79188       {
79189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79190       };
79191     } catch (...) {
79192       {
79193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79194       };
79195     }
79196   }
79197   jresult = (void *)result;
79198   return jresult;
79199 }
79200
79201
79202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79203   int jresult ;
79204   int result;
79205
79206   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79207   jresult = (int)result;
79208   return jresult;
79209 }
79210
79211
79212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79213   int jresult ;
79214   int result;
79215
79216   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79217   jresult = (int)result;
79218   return jresult;
79219 }
79220
79221
79222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79223   int jresult ;
79224   int result;
79225
79226   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79227   jresult = (int)result;
79228   return jresult;
79229 }
79230
79231
79232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79233   int jresult ;
79234   int result;
79235
79236   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79237   jresult = (int)result;
79238   return jresult;
79239 }
79240
79241
79242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79243   int jresult ;
79244   int result;
79245
79246   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79247   jresult = (int)result;
79248   return jresult;
79249 }
79250
79251
79252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79253   int jresult ;
79254   int result;
79255
79256   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79257   jresult = (int)result;
79258   return jresult;
79259 }
79260
79261
79262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79263   int jresult ;
79264   int result;
79265
79266   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79267   jresult = (int)result;
79268   return jresult;
79269 }
79270
79271
79272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79273   int jresult ;
79274   int result;
79275
79276   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79277   jresult = (int)result;
79278   return jresult;
79279 }
79280
79281
79282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79283   int jresult ;
79284   int result;
79285
79286   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79287   jresult = (int)result;
79288   return jresult;
79289 }
79290
79291
79292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79293   int jresult ;
79294   int result;
79295
79296   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79297   jresult = (int)result;
79298   return jresult;
79299 }
79300
79301
79302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79303   int jresult ;
79304   int result;
79305
79306   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79307   jresult = (int)result;
79308   return jresult;
79309 }
79310
79311
79312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79313   int jresult ;
79314   int result;
79315
79316   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79317   jresult = (int)result;
79318   return jresult;
79319 }
79320
79321
79322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79323   int jresult ;
79324   int result;
79325
79326   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79327   jresult = (int)result;
79328   return jresult;
79329 }
79330
79331
79332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79333   int jresult ;
79334   int result;
79335
79336   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79337   jresult = (int)result;
79338   return jresult;
79339 }
79340
79341
79342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79343   int jresult ;
79344   int result;
79345
79346   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79347   jresult = (int)result;
79348   return jresult;
79349 }
79350
79351
79352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79353   int jresult ;
79354   int result;
79355
79356   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79357   jresult = (int)result;
79358   return jresult;
79359 }
79360
79361
79362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79363   int jresult ;
79364   int result;
79365
79366   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79367   jresult = (int)result;
79368   return jresult;
79369 }
79370
79371
79372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79373   int jresult ;
79374   int result;
79375
79376   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79377   jresult = (int)result;
79378   return jresult;
79379 }
79380
79381
79382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79383   int jresult ;
79384   int result;
79385
79386   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79387   jresult = (int)result;
79388   return jresult;
79389 }
79390
79391
79392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79393   int jresult ;
79394   int result;
79395
79396   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79397   jresult = (int)result;
79398   return jresult;
79399 }
79400
79401
79402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79403   int jresult ;
79404   int result;
79405
79406   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79407   jresult = (int)result;
79408   return jresult;
79409 }
79410
79411
79412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79413   int jresult ;
79414   int result;
79415
79416   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79417   jresult = (int)result;
79418   return jresult;
79419 }
79420
79421
79422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79423   int jresult ;
79424   int result;
79425
79426   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79427   jresult = (int)result;
79428   return jresult;
79429 }
79430
79431
79432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79433   int jresult ;
79434   int result;
79435
79436   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79437   jresult = (int)result;
79438   return jresult;
79439 }
79440
79441
79442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79443   void * jresult ;
79444   Dali::Toolkit::TextLabel::Property *result = 0 ;
79445
79446   {
79447     try {
79448       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79449     } catch (std::out_of_range& e) {
79450       {
79451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79452       };
79453     } catch (std::exception& e) {
79454       {
79455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79456       };
79457     } catch (...) {
79458       {
79459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79460       };
79461     }
79462   }
79463   jresult = (void *)result;
79464   return jresult;
79465 }
79466
79467
79468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79469   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79470
79471   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79472   {
79473     try {
79474       delete arg1;
79475     } catch (std::out_of_range& e) {
79476       {
79477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79478       };
79479     } catch (std::exception& e) {
79480       {
79481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79482       };
79483     } catch (...) {
79484       {
79485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79486       };
79487     }
79488   }
79489 }
79490
79491
79492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79493   void * jresult ;
79494   Dali::Toolkit::TextLabel result;
79495
79496   {
79497     try {
79498       result = Dali::Toolkit::TextLabel::New();
79499     } catch (std::out_of_range& e) {
79500       {
79501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79502       };
79503     } catch (std::exception& e) {
79504       {
79505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79506       };
79507     } catch (...) {
79508       {
79509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79510       };
79511     }
79512   }
79513   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79514   return jresult;
79515 }
79516
79517
79518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79519   void * jresult ;
79520   std::string *arg1 = 0 ;
79521   Dali::Toolkit::TextLabel result;
79522
79523   if (!jarg1) {
79524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79525     return 0;
79526   }
79527   std::string arg1_str(jarg1);
79528   arg1 = &arg1_str;
79529   {
79530     try {
79531       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79532     } catch (std::out_of_range& e) {
79533       {
79534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79535       };
79536     } catch (std::exception& e) {
79537       {
79538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79539       };
79540     } catch (...) {
79541       {
79542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79543       };
79544     }
79545   }
79546   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79547
79548   //argout typemap for const std::string&
79549
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79555   void * jresult ;
79556   Dali::Toolkit::TextLabel *result = 0 ;
79557
79558   {
79559     try {
79560       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79561     } catch (std::out_of_range& e) {
79562       {
79563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79564       };
79565     } catch (std::exception& e) {
79566       {
79567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79568       };
79569     } catch (...) {
79570       {
79571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79572       };
79573     }
79574   }
79575   jresult = (void *)result;
79576   return jresult;
79577 }
79578
79579
79580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79581   void * jresult ;
79582   Dali::Toolkit::TextLabel *arg1 = 0 ;
79583   Dali::Toolkit::TextLabel *result = 0 ;
79584
79585   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79586   if (!arg1) {
79587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79588     return 0;
79589   }
79590   {
79591     try {
79592       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79593     } catch (std::out_of_range& e) {
79594       {
79595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79596       };
79597     } catch (std::exception& e) {
79598       {
79599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79604       };
79605     }
79606   }
79607   jresult = (void *)result;
79608   return jresult;
79609 }
79610
79611
79612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79613   void * jresult ;
79614   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79615   Dali::Toolkit::TextLabel *arg2 = 0 ;
79616   Dali::Toolkit::TextLabel *result = 0 ;
79617
79618   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79619   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79620   if (!arg2) {
79621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79622     return 0;
79623   }
79624   {
79625     try {
79626       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79627     } catch (std::out_of_range& e) {
79628       {
79629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79630       };
79631     } catch (std::exception& e) {
79632       {
79633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79634       };
79635     } catch (...) {
79636       {
79637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79638       };
79639     }
79640   }
79641   jresult = (void *)result;
79642   return jresult;
79643 }
79644
79645
79646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79647   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79648
79649   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79650   {
79651     try {
79652       delete arg1;
79653     } catch (std::out_of_range& e) {
79654       {
79655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79656       };
79657     } catch (std::exception& e) {
79658       {
79659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79664       };
79665     }
79666   }
79667 }
79668
79669
79670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79671   void * jresult ;
79672   Dali::BaseHandle arg1 ;
79673   Dali::BaseHandle *argp1 ;
79674   Dali::Toolkit::TextLabel result;
79675
79676   argp1 = (Dali::BaseHandle *)jarg1;
79677   if (!argp1) {
79678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79679     return 0;
79680   }
79681   arg1 = *argp1;
79682   {
79683     try {
79684       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79685     } catch (std::out_of_range& e) {
79686       {
79687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79688       };
79689     } catch (std::exception& e) {
79690       {
79691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79692       };
79693     } catch (...) {
79694       {
79695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79696       };
79697     }
79698   }
79699   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79700   return jresult;
79701 }
79702
79703
79704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79705   void * jresult ;
79706   Dali::Toolkit::AccessibilityManager *result = 0 ;
79707
79708   {
79709     try {
79710       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79711     } catch (std::out_of_range& e) {
79712       {
79713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79714       };
79715     } catch (std::exception& e) {
79716       {
79717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79718       };
79719     } catch (...) {
79720       {
79721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79722       };
79723     }
79724   }
79725   jresult = (void *)result;
79726   return jresult;
79727 }
79728
79729
79730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79732
79733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79734   {
79735     try {
79736       delete arg1;
79737     } catch (std::out_of_range& e) {
79738       {
79739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79740       };
79741     } catch (std::exception& e) {
79742       {
79743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79744       };
79745     } catch (...) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79748       };
79749     }
79750   }
79751 }
79752
79753
79754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79755   void * jresult ;
79756   Dali::Toolkit::AccessibilityManager result;
79757
79758   {
79759     try {
79760       result = Dali::Toolkit::AccessibilityManager::Get();
79761     } catch (std::out_of_range& e) {
79762       {
79763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79764       };
79765     } catch (std::exception& e) {
79766       {
79767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79768       };
79769     } catch (...) {
79770       {
79771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79772       };
79773     }
79774   }
79775   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79776   return jresult;
79777 }
79778
79779
79780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79781   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79782   Dali::Actor arg2 ;
79783   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79784   std::string *arg4 = 0 ;
79785   Dali::Actor *argp2 ;
79786
79787   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79788   argp2 = (Dali::Actor *)jarg2;
79789   if (!argp2) {
79790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79791     return ;
79792   }
79793   arg2 = *argp2;
79794   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79795   if (!jarg4) {
79796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79797     return ;
79798   }
79799   std::string arg4_str(jarg4);
79800   arg4 = &arg4_str;
79801   {
79802     try {
79803       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79804     } catch (std::out_of_range& e) {
79805       {
79806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79807       };
79808     } catch (std::exception& e) {
79809       {
79810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79811       };
79812     } catch (...) {
79813       {
79814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79815       };
79816     }
79817   }
79818
79819   //argout typemap for const std::string&
79820
79821 }
79822
79823
79824 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79825   char * jresult ;
79826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79827   Dali::Actor arg2 ;
79828   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79829   Dali::Actor *argp2 ;
79830   std::string result;
79831
79832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79833   argp2 = (Dali::Actor *)jarg2;
79834   if (!argp2) {
79835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79836     return 0;
79837   }
79838   arg2 = *argp2;
79839   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79840   {
79841     try {
79842       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79843     } catch (std::out_of_range& e) {
79844       {
79845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79846       };
79847     } catch (std::exception& e) {
79848       {
79849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79854       };
79855     }
79856   }
79857   jresult = SWIG_csharp_string_callback((&result)->c_str());
79858   return jresult;
79859 }
79860
79861
79862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79863   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79864   Dali::Actor arg2 ;
79865   unsigned int arg3 ;
79866   Dali::Actor *argp2 ;
79867
79868   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79869   argp2 = (Dali::Actor *)jarg2;
79870   if (!argp2) {
79871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79872     return ;
79873   }
79874   arg2 = *argp2;
79875   arg3 = (unsigned int)jarg3;
79876   {
79877     try {
79878       (arg1)->SetFocusOrder(arg2,arg3);
79879     } catch (std::out_of_range& e) {
79880       {
79881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79882       };
79883     } catch (std::exception& e) {
79884       {
79885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79886       };
79887     } catch (...) {
79888       {
79889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79890       };
79891     }
79892   }
79893 }
79894
79895
79896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79897   unsigned int jresult ;
79898   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79899   Dali::Actor arg2 ;
79900   Dali::Actor *argp2 ;
79901   unsigned int result;
79902
79903   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79904   argp2 = (Dali::Actor *)jarg2;
79905   if (!argp2) {
79906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79907     return 0;
79908   }
79909   arg2 = *argp2;
79910   {
79911     try {
79912       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (...) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79924       };
79925     }
79926   }
79927   jresult = result;
79928   return jresult;
79929 }
79930
79931
79932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79933   unsigned int jresult ;
79934   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79935   unsigned int result;
79936
79937   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79938   {
79939     try {
79940       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79948       };
79949     } catch (...) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79952       };
79953     }
79954   }
79955   jresult = result;
79956   return jresult;
79957 }
79958
79959
79960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79961   void * jresult ;
79962   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79963   unsigned int arg2 ;
79964   Dali::Actor result;
79965
79966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79967   arg2 = (unsigned int)jarg2;
79968   {
79969     try {
79970       result = (arg1)->GetActorByFocusOrder(arg2);
79971     } catch (std::out_of_range& e) {
79972       {
79973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79974       };
79975     } catch (std::exception& e) {
79976       {
79977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79978       };
79979     } catch (...) {
79980       {
79981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79982       };
79983     }
79984   }
79985   jresult = new Dali::Actor((const Dali::Actor &)result);
79986   return jresult;
79987 }
79988
79989
79990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79991   unsigned int jresult ;
79992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79993   Dali::Actor arg2 ;
79994   Dali::Actor *argp2 ;
79995   bool result;
79996
79997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79998   argp2 = (Dali::Actor *)jarg2;
79999   if (!argp2) {
80000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80001     return 0;
80002   }
80003   arg2 = *argp2;
80004   {
80005     try {
80006       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80007     } catch (std::out_of_range& e) {
80008       {
80009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80010       };
80011     } catch (std::exception& e) {
80012       {
80013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (...) {
80016       {
80017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80018       };
80019     }
80020   }
80021   jresult = result;
80022   return jresult;
80023 }
80024
80025
80026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80027   void * jresult ;
80028   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80029   Dali::Actor result;
80030
80031   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80032   {
80033     try {
80034       result = (arg1)->GetCurrentFocusActor();
80035     } catch (std::out_of_range& e) {
80036       {
80037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80038       };
80039     } catch (std::exception& e) {
80040       {
80041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80042       };
80043     } catch (...) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80046       };
80047     }
80048   }
80049   jresult = new Dali::Actor((const Dali::Actor &)result);
80050   return jresult;
80051 }
80052
80053
80054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80055   void * jresult ;
80056   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80057   Dali::Actor result;
80058
80059   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80060   {
80061     try {
80062       result = (arg1)->GetCurrentFocusGroup();
80063     } catch (std::out_of_range& e) {
80064       {
80065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80066       };
80067     } catch (std::exception& e) {
80068       {
80069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80070       };
80071     } catch (...) {
80072       {
80073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80074       };
80075     }
80076   }
80077   jresult = new Dali::Actor((const Dali::Actor &)result);
80078   return jresult;
80079 }
80080
80081
80082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80083   unsigned int jresult ;
80084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80085   unsigned int result;
80086
80087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80088   {
80089     try {
80090       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80091     } catch (std::out_of_range& e) {
80092       {
80093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80094       };
80095     } catch (std::exception& e) {
80096       {
80097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80098       };
80099     } catch (...) {
80100       {
80101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80102       };
80103     }
80104   }
80105   jresult = result;
80106   return jresult;
80107 }
80108
80109
80110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80111   unsigned int jresult ;
80112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80113   bool result;
80114
80115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80116   {
80117     try {
80118       result = (bool)(arg1)->MoveFocusForward();
80119     } catch (std::out_of_range& e) {
80120       {
80121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80122       };
80123     } catch (std::exception& e) {
80124       {
80125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80126       };
80127     } catch (...) {
80128       {
80129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80130       };
80131     }
80132   }
80133   jresult = result;
80134   return jresult;
80135 }
80136
80137
80138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80139   unsigned int jresult ;
80140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80141   bool result;
80142
80143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80144   {
80145     try {
80146       result = (bool)(arg1)->MoveFocusBackward();
80147     } catch (std::out_of_range& e) {
80148       {
80149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80150       };
80151     } catch (std::exception& e) {
80152       {
80153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80154       };
80155     } catch (...) {
80156       {
80157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80158       };
80159     }
80160   }
80161   jresult = result;
80162   return jresult;
80163 }
80164
80165
80166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80167   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80168
80169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80170   {
80171     try {
80172       (arg1)->ClearFocus();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80184       };
80185     }
80186   }
80187 }
80188
80189
80190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80192
80193   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80194   {
80195     try {
80196       (arg1)->Reset();
80197     } catch (std::out_of_range& e) {
80198       {
80199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80200       };
80201     } catch (std::exception& e) {
80202       {
80203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80204       };
80205     } catch (...) {
80206       {
80207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80208       };
80209     }
80210   }
80211 }
80212
80213
80214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80215   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80216   Dali::Actor arg2 ;
80217   bool arg3 ;
80218   Dali::Actor *argp2 ;
80219
80220   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80221   argp2 = (Dali::Actor *)jarg2;
80222   if (!argp2) {
80223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80224     return ;
80225   }
80226   arg2 = *argp2;
80227   arg3 = jarg3 ? true : false;
80228   {
80229     try {
80230       (arg1)->SetFocusGroup(arg2,arg3);
80231     } catch (std::out_of_range& e) {
80232       {
80233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80234       };
80235     } catch (std::exception& e) {
80236       {
80237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80238       };
80239     } catch (...) {
80240       {
80241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80242       };
80243     }
80244   }
80245 }
80246
80247
80248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80249   unsigned int jresult ;
80250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80251   Dali::Actor arg2 ;
80252   Dali::Actor *argp2 ;
80253   bool result;
80254
80255   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80256   argp2 = (Dali::Actor *)jarg2;
80257   if (!argp2) {
80258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80259     return 0;
80260   }
80261   arg2 = *argp2;
80262   {
80263     try {
80264       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80265     } catch (std::out_of_range& e) {
80266       {
80267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80268       };
80269     } catch (std::exception& e) {
80270       {
80271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (...) {
80274       {
80275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80276       };
80277     }
80278   }
80279   jresult = result;
80280   return jresult;
80281 }
80282
80283
80284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80285   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80286   bool arg2 ;
80287
80288   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80289   arg2 = jarg2 ? true : false;
80290   {
80291     try {
80292       (arg1)->SetGroupMode(arg2);
80293     } catch (std::out_of_range& e) {
80294       {
80295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80296       };
80297     } catch (std::exception& e) {
80298       {
80299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80304       };
80305     }
80306   }
80307 }
80308
80309
80310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80311   unsigned int jresult ;
80312   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80313   bool result;
80314
80315   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80316   {
80317     try {
80318       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80319     } catch (std::out_of_range& e) {
80320       {
80321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80322       };
80323     } catch (std::exception& e) {
80324       {
80325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80326       };
80327     } catch (...) {
80328       {
80329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80330       };
80331     }
80332   }
80333   jresult = result;
80334   return jresult;
80335 }
80336
80337
80338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80340   bool arg2 ;
80341
80342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80343   arg2 = jarg2 ? true : false;
80344   {
80345     try {
80346       (arg1)->SetWrapMode(arg2);
80347     } catch (std::out_of_range& e) {
80348       {
80349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80350       };
80351     } catch (std::exception& e) {
80352       {
80353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80354       };
80355     } catch (...) {
80356       {
80357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80358       };
80359     }
80360   }
80361 }
80362
80363
80364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80365   unsigned int jresult ;
80366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80367   bool result;
80368
80369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80370   {
80371     try {
80372       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80373     } catch (std::out_of_range& e) {
80374       {
80375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80376       };
80377     } catch (std::exception& e) {
80378       {
80379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (...) {
80382       {
80383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80384       };
80385     }
80386   }
80387   jresult = result;
80388   return jresult;
80389 }
80390
80391
80392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80393   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80394   Dali::Actor arg2 ;
80395   Dali::Actor *argp2 ;
80396
80397   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80398   argp2 = (Dali::Actor *)jarg2;
80399   if (!argp2) {
80400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80401     return ;
80402   }
80403   arg2 = *argp2;
80404   {
80405     try {
80406       (arg1)->SetFocusIndicatorActor(arg2);
80407     } catch (std::out_of_range& e) {
80408       {
80409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80410       };
80411     } catch (std::exception& e) {
80412       {
80413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80414       };
80415     } catch (...) {
80416       {
80417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80418       };
80419     }
80420   }
80421 }
80422
80423
80424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80425   void * jresult ;
80426   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80427   Dali::Actor result;
80428
80429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80430   {
80431     try {
80432       result = (arg1)->GetFocusIndicatorActor();
80433     } catch (std::out_of_range& e) {
80434       {
80435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80436       };
80437     } catch (std::exception& e) {
80438       {
80439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80444       };
80445     }
80446   }
80447   jresult = new Dali::Actor((const Dali::Actor &)result);
80448   return jresult;
80449 }
80450
80451
80452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80453   void * jresult ;
80454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80455   Dali::Actor arg2 ;
80456   Dali::Actor *argp2 ;
80457   Dali::Actor result;
80458
80459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80460   argp2 = (Dali::Actor *)jarg2;
80461   if (!argp2) {
80462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80463     return 0;
80464   }
80465   arg2 = *argp2;
80466   {
80467     try {
80468       result = (arg1)->GetFocusGroup(arg2);
80469     } catch (std::out_of_range& e) {
80470       {
80471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80472       };
80473     } catch (std::exception& e) {
80474       {
80475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80476       };
80477     } catch (...) {
80478       {
80479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80480       };
80481     }
80482   }
80483   jresult = new Dali::Actor((const Dali::Actor &)result);
80484   return jresult;
80485 }
80486
80487
80488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80489   void * jresult ;
80490   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80491   Dali::Vector2 result;
80492
80493   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80494   {
80495     try {
80496       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80497     } catch (std::out_of_range& e) {
80498       {
80499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80500       };
80501     } catch (std::exception& e) {
80502       {
80503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (...) {
80506       {
80507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80508       };
80509     }
80510   }
80511   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80512   return jresult;
80513 }
80514
80515
80516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80517   void * jresult ;
80518   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80519   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80520
80521   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80522   {
80523     try {
80524       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80525     } catch (std::out_of_range& e) {
80526       {
80527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80528       };
80529     } catch (std::exception& e) {
80530       {
80531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80532       };
80533     } catch (...) {
80534       {
80535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80536       };
80537     }
80538   }
80539   jresult = (void *)result;
80540   return jresult;
80541 }
80542
80543
80544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80545   void * jresult ;
80546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80547   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80548
80549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80550   {
80551     try {
80552       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80553     } catch (std::out_of_range& e) {
80554       {
80555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80556       };
80557     } catch (std::exception& e) {
80558       {
80559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80560       };
80561     } catch (...) {
80562       {
80563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80564       };
80565     }
80566   }
80567   jresult = (void *)result;
80568   return jresult;
80569 }
80570
80571
80572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80573   void * jresult ;
80574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80575   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80576
80577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80578   {
80579     try {
80580       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (...) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80592       };
80593     }
80594   }
80595   jresult = (void *)result;
80596   return jresult;
80597 }
80598
80599
80600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80601   void * jresult ;
80602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80603   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80604
80605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80606   {
80607     try {
80608       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80609     } catch (std::out_of_range& e) {
80610       {
80611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80612       };
80613     } catch (std::exception& e) {
80614       {
80615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80620       };
80621     }
80622   }
80623   jresult = (void *)result;
80624   return jresult;
80625 }
80626
80627
80628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80629   void * jresult ;
80630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80631   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80632
80633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80634   {
80635     try {
80636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80637     } catch (std::out_of_range& e) {
80638       {
80639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80640       };
80641     } catch (std::exception& e) {
80642       {
80643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (...) {
80646       {
80647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80648       };
80649     }
80650   }
80651   jresult = (void *)result;
80652   return jresult;
80653 }
80654
80655
80656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80657   void * jresult ;
80658   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80659   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80660
80661   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80662   {
80663     try {
80664       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80665     } catch (std::out_of_range& e) {
80666       {
80667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80668       };
80669     } catch (std::exception& e) {
80670       {
80671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80676       };
80677     }
80678   }
80679   jresult = (void *)result;
80680   return jresult;
80681 }
80682
80683
80684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80685   void * jresult ;
80686   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80687   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80688
80689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80690   {
80691     try {
80692       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80693     } catch (std::out_of_range& e) {
80694       {
80695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80696       };
80697     } catch (std::exception& e) {
80698       {
80699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80700       };
80701     } catch (...) {
80702       {
80703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80704       };
80705     }
80706   }
80707   jresult = (void *)result;
80708   return jresult;
80709 }
80710
80711
80712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80713   void * jresult ;
80714   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80715   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80716
80717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80718   {
80719     try {
80720       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80721     } catch (std::out_of_range& e) {
80722       {
80723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80724       };
80725     } catch (std::exception& e) {
80726       {
80727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80728       };
80729     } catch (...) {
80730       {
80731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80732       };
80733     }
80734   }
80735   jresult = (void *)result;
80736   return jresult;
80737 }
80738
80739
80740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80741   void * jresult ;
80742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80744
80745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80746   {
80747     try {
80748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (...) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80760       };
80761     }
80762   }
80763   jresult = (void *)result;
80764   return jresult;
80765 }
80766
80767
80768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80769   void * jresult ;
80770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80771   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80772
80773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80774   {
80775     try {
80776       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80777     } catch (std::out_of_range& e) {
80778       {
80779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80780       };
80781     } catch (std::exception& e) {
80782       {
80783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80784       };
80785     } catch (...) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80788       };
80789     }
80790   }
80791   jresult = (void *)result;
80792   return jresult;
80793 }
80794
80795
80796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80797   void * jresult ;
80798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80799   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80800
80801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80802   {
80803     try {
80804       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (...) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80816       };
80817     }
80818   }
80819   jresult = (void *)result;
80820   return jresult;
80821 }
80822
80823
80824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80825   void * jresult ;
80826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80827   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80828
80829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80830   {
80831     try {
80832       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80833     } catch (std::out_of_range& e) {
80834       {
80835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80836       };
80837     } catch (std::exception& e) {
80838       {
80839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (...) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80844       };
80845     }
80846   }
80847   jresult = (void *)result;
80848   return jresult;
80849 }
80850
80851
80852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80853   void * jresult ;
80854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80856
80857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80858   {
80859     try {
80860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80861     } catch (std::out_of_range& e) {
80862       {
80863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80864       };
80865     } catch (std::exception& e) {
80866       {
80867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80868       };
80869     } catch (...) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80872       };
80873     }
80874   }
80875   jresult = (void *)result;
80876   return jresult;
80877 }
80878
80879
80880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80881   void * jresult ;
80882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80883   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80884
80885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80886   {
80887     try {
80888       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80889     } catch (std::out_of_range& e) {
80890       {
80891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80892       };
80893     } catch (std::exception& e) {
80894       {
80895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80896       };
80897     } catch (...) {
80898       {
80899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80900       };
80901     }
80902   }
80903   jresult = (void *)result;
80904   return jresult;
80905 }
80906
80907
80908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80909   void * jresult ;
80910   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80911   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80912
80913   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80914   {
80915     try {
80916       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80917     } catch (std::out_of_range& e) {
80918       {
80919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80920       };
80921     } catch (std::exception& e) {
80922       {
80923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80924       };
80925     } catch (...) {
80926       {
80927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80928       };
80929     }
80930   }
80931   jresult = (void *)result;
80932   return jresult;
80933 }
80934
80935
80936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80937   void * jresult ;
80938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80939   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80940
80941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80942   {
80943     try {
80944       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80945     } catch (std::out_of_range& e) {
80946       {
80947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80948       };
80949     } catch (std::exception& e) {
80950       {
80951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80952       };
80953     } catch (...) {
80954       {
80955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80956       };
80957     }
80958   }
80959   jresult = (void *)result;
80960   return jresult;
80961 }
80962
80963
80964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80965   void * jresult ;
80966   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80967   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80968
80969   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80970   {
80971     try {
80972       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80973     } catch (std::out_of_range& e) {
80974       {
80975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80976       };
80977     } catch (std::exception& e) {
80978       {
80979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80980       };
80981     } catch (...) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80984       };
80985     }
80986   }
80987   jresult = (void *)result;
80988   return jresult;
80989 }
80990
80991
80992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80993   void * jresult ;
80994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80995   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80996
80997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80998   {
80999     try {
81000       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81001     } catch (std::out_of_range& e) {
81002       {
81003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81004       };
81005     } catch (std::exception& e) {
81006       {
81007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81008       };
81009     } catch (...) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81012       };
81013     }
81014   }
81015   jresult = (void *)result;
81016   return jresult;
81017 }
81018
81019
81020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81021   void * jresult ;
81022   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81023   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81024
81025   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81026   {
81027     try {
81028       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81029     } catch (std::out_of_range& e) {
81030       {
81031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81032       };
81033     } catch (std::exception& e) {
81034       {
81035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81036       };
81037     } catch (...) {
81038       {
81039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81040       };
81041     }
81042   }
81043   jresult = (void *)result;
81044   return jresult;
81045 }
81046
81047
81048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81049   void * jresult ;
81050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81051   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81052
81053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81054   {
81055     try {
81056       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (...) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81068       };
81069     }
81070   }
81071   jresult = (void *)result;
81072   return jresult;
81073 }
81074
81075
81076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81077   void * jresult ;
81078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81079   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81080
81081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81082   {
81083     try {
81084       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81085     } catch (std::out_of_range& e) {
81086       {
81087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81088       };
81089     } catch (std::exception& e) {
81090       {
81091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81096       };
81097     }
81098   }
81099   jresult = (void *)result;
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81105   void * jresult ;
81106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81108
81109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81110   {
81111     try {
81112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81120       };
81121     } catch (...) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81124       };
81125     }
81126   }
81127   jresult = (void *)result;
81128   return jresult;
81129 }
81130
81131
81132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81133   void * jresult ;
81134   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81135   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81136
81137   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81138   {
81139     try {
81140       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81141     } catch (std::out_of_range& e) {
81142       {
81143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81144       };
81145     } catch (std::exception& e) {
81146       {
81147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81148       };
81149     } catch (...) {
81150       {
81151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81152       };
81153     }
81154   }
81155   jresult = (void *)result;
81156   return jresult;
81157 }
81158
81159
81160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81161   void * jresult ;
81162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81163   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81164
81165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81166   {
81167     try {
81168       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81169     } catch (std::out_of_range& e) {
81170       {
81171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81172       };
81173     } catch (std::exception& e) {
81174       {
81175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81176       };
81177     } catch (...) {
81178       {
81179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81180       };
81181     }
81182   }
81183   jresult = (void *)result;
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81189   void * jresult ;
81190   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81191   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81192
81193   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81194   {
81195     try {
81196       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81197     } catch (std::out_of_range& e) {
81198       {
81199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81200       };
81201     } catch (std::exception& e) {
81202       {
81203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81204       };
81205     } catch (...) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81208       };
81209     }
81210   }
81211   jresult = (void *)result;
81212   return jresult;
81213 }
81214
81215
81216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81217   void * jresult ;
81218   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81219   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81220
81221   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81222   {
81223     try {
81224       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81225     } catch (std::out_of_range& e) {
81226       {
81227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81228       };
81229     } catch (std::exception& e) {
81230       {
81231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81232       };
81233     } catch (...) {
81234       {
81235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81236       };
81237     }
81238   }
81239   jresult = (void *)result;
81240   return jresult;
81241 }
81242
81243
81244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81245   void * jresult ;
81246   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81247   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81248
81249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81250   {
81251     try {
81252       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81260       };
81261     } catch (...) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81264       };
81265     }
81266   }
81267   jresult = (void *)result;
81268   return jresult;
81269 }
81270
81271
81272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81273   void * jresult ;
81274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81275   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81276
81277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81278   {
81279     try {
81280       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81281     } catch (std::out_of_range& e) {
81282       {
81283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81284       };
81285     } catch (std::exception& e) {
81286       {
81287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81288       };
81289     } catch (...) {
81290       {
81291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81292       };
81293     }
81294   }
81295   jresult = (void *)result;
81296   return jresult;
81297 }
81298
81299
81300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81301   void * jresult ;
81302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81303   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81304
81305   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81306   {
81307     try {
81308       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81320       };
81321     }
81322   }
81323   jresult = (void *)result;
81324   return jresult;
81325 }
81326
81327
81328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81329   void * jresult ;
81330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81331   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81332
81333   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81334   {
81335     try {
81336       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (...) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81348       };
81349     }
81350   }
81351   jresult = (void *)result;
81352   return jresult;
81353 }
81354
81355
81356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81357   void * jresult ;
81358   Dali::Toolkit::StyleManager *result = 0 ;
81359
81360   {
81361     try {
81362       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81363     } catch (std::out_of_range& e) {
81364       {
81365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81366       };
81367     } catch (std::exception& e) {
81368       {
81369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81370       };
81371     } catch (...) {
81372       {
81373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81374       };
81375     }
81376   }
81377   jresult = (void *)result;
81378   return jresult;
81379 }
81380
81381
81382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81383   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81384
81385   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81386   {
81387     try {
81388       delete arg1;
81389     } catch (std::out_of_range& e) {
81390       {
81391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81392       };
81393     } catch (std::exception& e) {
81394       {
81395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81396       };
81397     } catch (...) {
81398       {
81399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81400       };
81401     }
81402   }
81403 }
81404
81405
81406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81407   void * jresult ;
81408   Dali::Toolkit::StyleManager result;
81409
81410   {
81411     try {
81412       result = Dali::Toolkit::StyleManager::Get();
81413     } catch (std::out_of_range& e) {
81414       {
81415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81416       };
81417     } catch (std::exception& e) {
81418       {
81419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81420       };
81421     } catch (...) {
81422       {
81423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81424       };
81425     }
81426   }
81427   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81428   return jresult;
81429 }
81430
81431
81432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81433   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81434   std::string *arg2 = 0 ;
81435
81436   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81437   if (!jarg2) {
81438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81439     return ;
81440   }
81441   std::string arg2_str(jarg2);
81442   arg2 = &arg2_str;
81443   {
81444     try {
81445       (arg1)->ApplyTheme((std::string const &)*arg2);
81446     } catch (std::out_of_range& e) {
81447       {
81448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81449       };
81450     } catch (std::exception& e) {
81451       {
81452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81453       };
81454     } catch (...) {
81455       {
81456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81457       };
81458     }
81459   }
81460
81461   //argout typemap for const std::string&
81462
81463 }
81464
81465
81466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81467   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81468
81469   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81470   {
81471     try {
81472       (arg1)->ApplyDefaultTheme();
81473     } catch (std::out_of_range& e) {
81474       {
81475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81476       };
81477     } catch (std::exception& e) {
81478       {
81479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81484       };
81485     }
81486   }
81487 }
81488
81489
81490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81491   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81492   std::string *arg2 = 0 ;
81493   Dali::Property::Value *arg3 = 0 ;
81494
81495   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81496   if (!jarg2) {
81497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81498     return ;
81499   }
81500   std::string arg2_str(jarg2);
81501   arg2 = &arg2_str;
81502   arg3 = (Dali::Property::Value *)jarg3;
81503   if (!arg3) {
81504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81505     return ;
81506   }
81507   {
81508     try {
81509       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81510     } catch (std::out_of_range& e) {
81511       {
81512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81513       };
81514     } catch (std::exception& e) {
81515       {
81516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81517       };
81518     } catch (...) {
81519       {
81520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81521       };
81522     }
81523   }
81524
81525   //argout typemap for const std::string&
81526
81527 }
81528
81529
81530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81531   unsigned int jresult ;
81532   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81533   std::string *arg2 = 0 ;
81534   Dali::Property::Value *arg3 = 0 ;
81535   bool result;
81536
81537   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81538   if (!jarg2) {
81539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81540     return 0;
81541   }
81542   std::string arg2_str(jarg2);
81543   arg2 = &arg2_str;
81544   arg3 = (Dali::Property::Value *)jarg3;
81545   if (!arg3) {
81546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81547     return 0;
81548   }
81549   {
81550     try {
81551       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81563       };
81564     }
81565   }
81566   jresult = result;
81567
81568   //argout typemap for const std::string&
81569
81570   return jresult;
81571 }
81572
81573
81574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81575   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81576   Dali::Toolkit::Control arg2 ;
81577   std::string *arg3 = 0 ;
81578   std::string *arg4 = 0 ;
81579   Dali::Toolkit::Control *argp2 ;
81580
81581   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81582   argp2 = (Dali::Toolkit::Control *)jarg2;
81583   if (!argp2) {
81584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81585     return ;
81586   }
81587   arg2 = *argp2;
81588   if (!jarg3) {
81589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81590     return ;
81591   }
81592   std::string arg3_str(jarg3);
81593   arg3 = &arg3_str;
81594   if (!jarg4) {
81595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81596     return ;
81597   }
81598   std::string arg4_str(jarg4);
81599   arg4 = &arg4_str;
81600   {
81601     try {
81602       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81610       };
81611     } catch (...) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81614       };
81615     }
81616   }
81617
81618   //argout typemap for const std::string&
81619
81620
81621   //argout typemap for const std::string&
81622
81623 }
81624
81625
81626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81627   void * jresult ;
81628   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81629   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81630
81631   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81632   {
81633     try {
81634       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81635     } catch (std::out_of_range& e) {
81636       {
81637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81638       };
81639     } catch (std::exception& e) {
81640       {
81641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81642       };
81643     } catch (...) {
81644       {
81645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81646       };
81647     }
81648   }
81649   jresult = (void *)result;
81650   return jresult;
81651 }
81652
81653
81654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81655   int jresult ;
81656   int result;
81657
81658   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81659   jresult = (int)result;
81660   return jresult;
81661 }
81662
81663
81664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81665   int jresult ;
81666   int result;
81667
81668   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81669   jresult = (int)result;
81670   return jresult;
81671 }
81672
81673
81674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81675   int jresult ;
81676   int result;
81677
81678   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81679   jresult = (int)result;
81680   return jresult;
81681 }
81682
81683
81684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81685   int jresult ;
81686   int result;
81687
81688   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81689   jresult = (int)result;
81690   return jresult;
81691 }
81692
81693
81694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81695   int jresult ;
81696   int result;
81697
81698   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81699   jresult = (int)result;
81700   return jresult;
81701 }
81702
81703
81704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81705   int jresult ;
81706   int result;
81707
81708   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81709   jresult = (int)result;
81710   return jresult;
81711 }
81712
81713
81714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81715   int jresult ;
81716   int result;
81717
81718   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81719   jresult = (int)result;
81720   return jresult;
81721 }
81722
81723
81724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81725   int jresult ;
81726   int result;
81727
81728   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81729   jresult = (int)result;
81730   return jresult;
81731 }
81732
81733
81734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81735   int jresult ;
81736   int result;
81737
81738   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81739   jresult = (int)result;
81740   return jresult;
81741 }
81742
81743
81744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81745   int jresult ;
81746   int result;
81747
81748   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81749   jresult = (int)result;
81750   return jresult;
81751 }
81752
81753
81754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81755   int jresult ;
81756   int result;
81757
81758   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81759   jresult = (int)result;
81760   return jresult;
81761 }
81762
81763
81764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81765   int jresult ;
81766   int result;
81767
81768   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81769   jresult = (int)result;
81770   return jresult;
81771 }
81772
81773
81774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81775   int jresult ;
81776   int result;
81777
81778   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81779   jresult = (int)result;
81780   return jresult;
81781 }
81782
81783
81784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81785   int jresult ;
81786   int result;
81787
81788   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81789   jresult = (int)result;
81790   return jresult;
81791 }
81792
81793
81794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81795   int jresult ;
81796   int result;
81797
81798   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81799   jresult = (int)result;
81800   return jresult;
81801 }
81802
81803
81804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81805   void * jresult ;
81806   Dali::Toolkit::Slider::Property *result = 0 ;
81807
81808   {
81809     try {
81810       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81811     } catch (std::out_of_range& e) {
81812       {
81813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81814       };
81815     } catch (std::exception& e) {
81816       {
81817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81818       };
81819     } catch (...) {
81820       {
81821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81822       };
81823     }
81824   }
81825   jresult = (void *)result;
81826   return jresult;
81827 }
81828
81829
81830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81831   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81832
81833   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81834   {
81835     try {
81836       delete arg1;
81837     } catch (std::out_of_range& e) {
81838       {
81839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81840       };
81841     } catch (std::exception& e) {
81842       {
81843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81844       };
81845     } catch (...) {
81846       {
81847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81848       };
81849     }
81850   }
81851 }
81852
81853
81854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81855   void * jresult ;
81856   Dali::Toolkit::Slider result;
81857
81858   {
81859     try {
81860       result = Dali::Toolkit::Slider::New();
81861     } catch (std::out_of_range& e) {
81862       {
81863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81864       };
81865     } catch (std::exception& e) {
81866       {
81867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81868       };
81869     } catch (...) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81872       };
81873     }
81874   }
81875   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81876   return jresult;
81877 }
81878
81879
81880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81881   void * jresult ;
81882   Dali::Toolkit::Slider *result = 0 ;
81883
81884   {
81885     try {
81886       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81894       };
81895     } catch (...) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81898       };
81899     }
81900   }
81901   jresult = (void *)result;
81902   return jresult;
81903 }
81904
81905
81906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81907   void * jresult ;
81908   Dali::Toolkit::Slider *arg1 = 0 ;
81909   Dali::Toolkit::Slider *result = 0 ;
81910
81911   arg1 = (Dali::Toolkit::Slider *)jarg1;
81912   if (!arg1) {
81913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81914     return 0;
81915   }
81916   {
81917     try {
81918       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81930       };
81931     }
81932   }
81933   jresult = (void *)result;
81934   return jresult;
81935 }
81936
81937
81938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81939   void * jresult ;
81940   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81941   Dali::Toolkit::Slider *arg2 = 0 ;
81942   Dali::Toolkit::Slider *result = 0 ;
81943
81944   arg1 = (Dali::Toolkit::Slider *)jarg1;
81945   arg2 = (Dali::Toolkit::Slider *)jarg2;
81946   if (!arg2) {
81947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81948     return 0;
81949   }
81950   {
81951     try {
81952       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81953     } catch (std::out_of_range& e) {
81954       {
81955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (std::exception& e) {
81958       {
81959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81964       };
81965     }
81966   }
81967   jresult = (void *)result;
81968   return jresult;
81969 }
81970
81971
81972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81973   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81974
81975   arg1 = (Dali::Toolkit::Slider *)jarg1;
81976   {
81977     try {
81978       delete arg1;
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (...) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81990       };
81991     }
81992   }
81993 }
81994
81995
81996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81997   void * jresult ;
81998   Dali::BaseHandle arg1 ;
81999   Dali::BaseHandle *argp1 ;
82000   Dali::Toolkit::Slider result;
82001
82002   argp1 = (Dali::BaseHandle *)jarg1;
82003   if (!argp1) {
82004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82005     return 0;
82006   }
82007   arg1 = *argp1;
82008   {
82009     try {
82010       result = Dali::Toolkit::Slider::DownCast(arg1);
82011     } catch (std::out_of_range& e) {
82012       {
82013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82014       };
82015     } catch (std::exception& e) {
82016       {
82017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82018       };
82019     } catch (...) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82022       };
82023     }
82024   }
82025   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82026   return jresult;
82027 }
82028
82029
82030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82031   void * jresult ;
82032   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82033   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82034
82035   arg1 = (Dali::Toolkit::Slider *)jarg1;
82036   {
82037     try {
82038       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82039     } catch (std::out_of_range& e) {
82040       {
82041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82042       };
82043     } catch (std::exception& e) {
82044       {
82045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82046       };
82047     } catch (...) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82050       };
82051     }
82052   }
82053   jresult = (void *)result;
82054   return jresult;
82055 }
82056
82057
82058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82059   void * jresult ;
82060   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82061   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82062
82063   arg1 = (Dali::Toolkit::Slider *)jarg1;
82064   {
82065     try {
82066       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82067     } catch (std::out_of_range& e) {
82068       {
82069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82070       };
82071     } catch (std::exception& e) {
82072       {
82073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82074       };
82075     } catch (...) {
82076       {
82077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82078       };
82079     }
82080   }
82081   jresult = (void *)result;
82082   return jresult;
82083 }
82084
82085
82086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82087   void * jresult ;
82088   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82089   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82090
82091   arg1 = (Dali::Toolkit::Slider *)jarg1;
82092   {
82093     try {
82094       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82095     } catch (std::out_of_range& e) {
82096       {
82097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82098       };
82099     } catch (std::exception& e) {
82100       {
82101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82102       };
82103     } catch (...) {
82104       {
82105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82106       };
82107     }
82108   }
82109   jresult = (void *)result;
82110   return jresult;
82111 }
82112
82113
82114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82115   int jresult ;
82116   int result;
82117
82118   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82119   jresult = (int)result;
82120   return jresult;
82121 }
82122
82123
82124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82125   int jresult ;
82126   int result;
82127
82128   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82129   jresult = (int)result;
82130   return jresult;
82131 }
82132
82133
82134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82135   int jresult ;
82136   int result;
82137
82138   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82139   jresult = (int)result;
82140   return jresult;
82141 }
82142
82143
82144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82145   int jresult ;
82146   int result;
82147
82148   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82149   jresult = (int)result;
82150   return jresult;
82151 }
82152
82153
82154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82155   void * jresult ;
82156   Dali::Toolkit::VideoView::Property *result = 0 ;
82157
82158   {
82159     try {
82160       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82161     } catch (std::out_of_range& e) {
82162       {
82163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (std::exception& e) {
82166       {
82167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82172       };
82173     }
82174   }
82175   jresult = (void *)result;
82176   return jresult;
82177 }
82178
82179
82180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82181   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82182
82183   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82184   {
82185     try {
82186       delete arg1;
82187     } catch (std::out_of_range& e) {
82188       {
82189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (std::exception& e) {
82192       {
82193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82198       };
82199     }
82200   }
82201 }
82202
82203
82204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82205   void * jresult ;
82206   Dali::Toolkit::VideoView result;
82207
82208   {
82209     try {
82210       result = Dali::Toolkit::VideoView::New();
82211     } catch (std::out_of_range& e) {
82212       {
82213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82214       };
82215     } catch (std::exception& e) {
82216       {
82217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82218       };
82219     } catch (...) {
82220       {
82221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82222       };
82223     }
82224   }
82225   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82226   return jresult;
82227 }
82228
82229
82230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82231   void * jresult ;
82232   std::string *arg1 = 0 ;
82233   Dali::Toolkit::VideoView result;
82234
82235   if (!jarg1) {
82236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82237     return 0;
82238   }
82239   std::string arg1_str(jarg1);
82240   arg1 = &arg1_str;
82241   {
82242     try {
82243       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82244     } catch (std::out_of_range& e) {
82245       {
82246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82247       };
82248     } catch (std::exception& e) {
82249       {
82250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82251       };
82252     } catch (...) {
82253       {
82254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82255       };
82256     }
82257   }
82258   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82259
82260   //argout typemap for const std::string&
82261
82262   return jresult;
82263 }
82264
82265
82266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82267   void * jresult ;
82268   Dali::Toolkit::VideoView *result = 0 ;
82269
82270   {
82271     try {
82272       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82273     } catch (std::out_of_range& e) {
82274       {
82275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82276       };
82277     } catch (std::exception& e) {
82278       {
82279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82280       };
82281     } catch (...) {
82282       {
82283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82284       };
82285     }
82286   }
82287   jresult = (void *)result;
82288   return jresult;
82289 }
82290
82291
82292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82293   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82294
82295   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82296   {
82297     try {
82298       delete arg1;
82299     } catch (std::out_of_range& e) {
82300       {
82301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (std::exception& e) {
82304       {
82305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313 }
82314
82315
82316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82317   void * jresult ;
82318   Dali::Toolkit::VideoView *arg1 = 0 ;
82319   Dali::Toolkit::VideoView *result = 0 ;
82320
82321   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82322   if (!arg1) {
82323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82324     return 0;
82325   }
82326   {
82327     try {
82328       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82329     } catch (std::out_of_range& e) {
82330       {
82331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82332       };
82333     } catch (std::exception& e) {
82334       {
82335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82336       };
82337     } catch (...) {
82338       {
82339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82340       };
82341     }
82342   }
82343   jresult = (void *)result;
82344   return jresult;
82345 }
82346
82347
82348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82349   void * jresult ;
82350   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82351   Dali::Toolkit::VideoView *arg2 = 0 ;
82352   Dali::Toolkit::VideoView *result = 0 ;
82353
82354   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82355   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82356   if (!arg2) {
82357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82358     return 0;
82359   }
82360   {
82361     try {
82362       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82363     } catch (std::out_of_range& e) {
82364       {
82365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82366       };
82367     } catch (std::exception& e) {
82368       {
82369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (...) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82374       };
82375     }
82376   }
82377   jresult = (void *)result;
82378   return jresult;
82379 }
82380
82381
82382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82383   void * jresult ;
82384   Dali::BaseHandle arg1 ;
82385   Dali::BaseHandle *argp1 ;
82386   Dali::Toolkit::VideoView result;
82387
82388   argp1 = (Dali::BaseHandle *)jarg1;
82389   if (!argp1) {
82390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82391     return 0;
82392   }
82393   arg1 = *argp1;
82394   {
82395     try {
82396       result = Dali::Toolkit::VideoView::DownCast(arg1);
82397     } catch (std::out_of_range& e) {
82398       {
82399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82400       };
82401     } catch (std::exception& e) {
82402       {
82403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82404       };
82405     } catch (...) {
82406       {
82407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82408       };
82409     }
82410   }
82411   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82412   return jresult;
82413 }
82414
82415
82416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82417   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82418
82419   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82420   {
82421     try {
82422       (arg1)->Play();
82423     } catch (std::out_of_range& e) {
82424       {
82425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82426       };
82427     } catch (std::exception& e) {
82428       {
82429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82430       };
82431     } catch (...) {
82432       {
82433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82434       };
82435     }
82436   }
82437 }
82438
82439
82440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82441   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82442
82443   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82444   {
82445     try {
82446       (arg1)->Pause();
82447     } catch (std::out_of_range& e) {
82448       {
82449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82450       };
82451     } catch (std::exception& e) {
82452       {
82453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82454       };
82455     } catch (...) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82458       };
82459     }
82460   }
82461 }
82462
82463
82464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82465   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82466
82467   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82468   {
82469     try {
82470       (arg1)->Stop();
82471     } catch (std::out_of_range& e) {
82472       {
82473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82474       };
82475     } catch (std::exception& e) {
82476       {
82477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82478       };
82479     } catch (...) {
82480       {
82481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82482       };
82483     }
82484   }
82485 }
82486
82487
82488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82489   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82490   int arg2 ;
82491
82492   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82493   arg2 = (int)jarg2;
82494   {
82495     try {
82496       (arg1)->Forward(arg2);
82497     } catch (std::out_of_range& e) {
82498       {
82499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (std::exception& e) {
82502       {
82503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (...) {
82506       {
82507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82508       };
82509     }
82510   }
82511 }
82512
82513
82514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82515   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82516   int arg2 ;
82517
82518   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82519   arg2 = (int)jarg2;
82520   {
82521     try {
82522       (arg1)->Backward(arg2);
82523     } catch (std::out_of_range& e) {
82524       {
82525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82526       };
82527     } catch (std::exception& e) {
82528       {
82529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82530       };
82531     } catch (...) {
82532       {
82533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82534       };
82535     }
82536   }
82537 }
82538
82539
82540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82541   void * jresult ;
82542   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82543   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82544
82545   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82546   {
82547     try {
82548       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82549     } catch (std::out_of_range& e) {
82550       {
82551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82552       };
82553     } catch (std::exception& e) {
82554       {
82555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82556       };
82557     } catch (...) {
82558       {
82559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82560       };
82561     }
82562   }
82563   jresult = (void *)result;
82564   return jresult;
82565 }
82566
82567
82568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82569   int jresult ;
82570   int result;
82571
82572   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82573   jresult = (int)result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82579   int jresult ;
82580   int result;
82581
82582   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82583   jresult = (int)result;
82584   return jresult;
82585 }
82586
82587
82588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82589   int jresult ;
82590   int result;
82591
82592   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82593   jresult = (int)result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82599   int jresult ;
82600   int result;
82601
82602   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82603   jresult = (int)result;
82604   return jresult;
82605 }
82606
82607
82608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82609   int jresult ;
82610   int result;
82611
82612   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82613   jresult = (int)result;
82614   return jresult;
82615 }
82616
82617
82618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82619   int jresult ;
82620   int result;
82621
82622   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82623   jresult = (int)result;
82624   return jresult;
82625 }
82626
82627
82628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82629   int jresult ;
82630   int result;
82631
82632   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82633   jresult = (int)result;
82634   return jresult;
82635 }
82636
82637
82638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82639   int jresult ;
82640   int result;
82641
82642   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82643   jresult = (int)result;
82644   return jresult;
82645 }
82646
82647
82648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82649   int jresult ;
82650   int result;
82651
82652   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82653   jresult = (int)result;
82654   return jresult;
82655 }
82656
82657
82658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82659   int jresult ;
82660   int result;
82661
82662   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82663   jresult = (int)result;
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82669   int jresult ;
82670   int result;
82671
82672   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82673   jresult = (int)result;
82674   return jresult;
82675 }
82676
82677
82678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82679   int jresult ;
82680   int result;
82681
82682   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82683   jresult = (int)result;
82684   return jresult;
82685 }
82686
82687
82688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82689   int jresult ;
82690   int result;
82691
82692   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82693   jresult = (int)result;
82694   return jresult;
82695 }
82696
82697
82698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82699   int jresult ;
82700   int result;
82701
82702   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82703   jresult = (int)result;
82704   return jresult;
82705 }
82706
82707
82708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82709   int jresult ;
82710   int result;
82711
82712   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82713   jresult = (int)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82719   int jresult ;
82720   int result;
82721
82722   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82723   jresult = (int)result;
82724   return jresult;
82725 }
82726
82727
82728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82729   int jresult ;
82730   int result;
82731
82732   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82733   jresult = (int)result;
82734   return jresult;
82735 }
82736
82737
82738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82739   int jresult ;
82740   int result;
82741
82742   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82743   jresult = (int)result;
82744   return jresult;
82745 }
82746
82747
82748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82749   int jresult ;
82750   int result;
82751
82752   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82753   jresult = (int)result;
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82759   int jresult ;
82760   int result;
82761
82762   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82763   jresult = (int)result;
82764   return jresult;
82765 }
82766
82767
82768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82769   int jresult ;
82770   int result;
82771
82772   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82773   jresult = (int)result;
82774   return jresult;
82775 }
82776
82777
82778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82779   void * jresult ;
82780   Dali::Toolkit::Popup::Property *result = 0 ;
82781
82782   {
82783     try {
82784       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82785     } catch (std::out_of_range& e) {
82786       {
82787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82788       };
82789     } catch (std::exception& e) {
82790       {
82791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82792       };
82793     } catch (...) {
82794       {
82795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82796       };
82797     }
82798   }
82799   jresult = (void *)result;
82800   return jresult;
82801 }
82802
82803
82804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82805   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82806
82807   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82808   {
82809     try {
82810       delete arg1;
82811     } catch (std::out_of_range& e) {
82812       {
82813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82814       };
82815     } catch (std::exception& e) {
82816       {
82817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82818       };
82819     } catch (...) {
82820       {
82821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82822       };
82823     }
82824   }
82825 }
82826
82827
82828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82829   void * jresult ;
82830   Dali::Toolkit::Popup *result = 0 ;
82831
82832   {
82833     try {
82834       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82835     } catch (std::out_of_range& e) {
82836       {
82837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82838       };
82839     } catch (std::exception& e) {
82840       {
82841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82842       };
82843     } catch (...) {
82844       {
82845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82846       };
82847     }
82848   }
82849   jresult = (void *)result;
82850   return jresult;
82851 }
82852
82853
82854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82855   void * jresult ;
82856   Dali::Toolkit::Popup result;
82857
82858   {
82859     try {
82860       result = Dali::Toolkit::Popup::New();
82861     } catch (std::out_of_range& e) {
82862       {
82863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82864       };
82865     } catch (std::exception& e) {
82866       {
82867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82868       };
82869     } catch (...) {
82870       {
82871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82872       };
82873     }
82874   }
82875   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82876   return jresult;
82877 }
82878
82879
82880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82881   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82882
82883   arg1 = (Dali::Toolkit::Popup *)jarg1;
82884   {
82885     try {
82886       delete arg1;
82887     } catch (std::out_of_range& e) {
82888       {
82889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82890       };
82891     } catch (std::exception& e) {
82892       {
82893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82894       };
82895     } catch (...) {
82896       {
82897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82898       };
82899     }
82900   }
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82905   void * jresult ;
82906   Dali::Toolkit::Popup *arg1 = 0 ;
82907   Dali::Toolkit::Popup *result = 0 ;
82908
82909   arg1 = (Dali::Toolkit::Popup *)jarg1;
82910   if (!arg1) {
82911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82912     return 0;
82913   }
82914   {
82915     try {
82916       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (...) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82928       };
82929     }
82930   }
82931   jresult = (void *)result;
82932   return jresult;
82933 }
82934
82935
82936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82937   void * jresult ;
82938   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82939   Dali::Toolkit::Popup *arg2 = 0 ;
82940   Dali::Toolkit::Popup *result = 0 ;
82941
82942   arg1 = (Dali::Toolkit::Popup *)jarg1;
82943   arg2 = (Dali::Toolkit::Popup *)jarg2;
82944   if (!arg2) {
82945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82946     return 0;
82947   }
82948   {
82949     try {
82950       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82951     } catch (std::out_of_range& e) {
82952       {
82953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82954       };
82955     } catch (std::exception& e) {
82956       {
82957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82958       };
82959     } catch (...) {
82960       {
82961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82962       };
82963     }
82964   }
82965   jresult = (void *)result;
82966   return jresult;
82967 }
82968
82969
82970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82971   void * jresult ;
82972   Dali::BaseHandle arg1 ;
82973   Dali::BaseHandle *argp1 ;
82974   Dali::Toolkit::Popup result;
82975
82976   argp1 = (Dali::BaseHandle *)jarg1;
82977   if (!argp1) {
82978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82979     return 0;
82980   }
82981   arg1 = *argp1;
82982   {
82983     try {
82984       result = Dali::Toolkit::Popup::DownCast(arg1);
82985     } catch (std::out_of_range& e) {
82986       {
82987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82988       };
82989     } catch (std::exception& e) {
82990       {
82991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82992       };
82993     } catch (...) {
82994       {
82995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82996       };
82997     }
82998   }
82999   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83000   return jresult;
83001 }
83002
83003
83004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83005   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83006   Dali::Actor arg2 ;
83007   Dali::Actor *argp2 ;
83008
83009   arg1 = (Dali::Toolkit::Popup *)jarg1;
83010   argp2 = (Dali::Actor *)jarg2;
83011   if (!argp2) {
83012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83013     return ;
83014   }
83015   arg2 = *argp2;
83016   {
83017     try {
83018       (arg1)->SetTitle(arg2);
83019     } catch (std::out_of_range& e) {
83020       {
83021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83022       };
83023     } catch (std::exception& e) {
83024       {
83025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83026       };
83027     } catch (...) {
83028       {
83029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83030       };
83031     }
83032   }
83033 }
83034
83035
83036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83037   void * jresult ;
83038   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83039   Dali::Actor result;
83040
83041   arg1 = (Dali::Toolkit::Popup *)jarg1;
83042   {
83043     try {
83044       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83045     } catch (std::out_of_range& e) {
83046       {
83047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83048       };
83049     } catch (std::exception& e) {
83050       {
83051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (...) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83056       };
83057     }
83058   }
83059   jresult = new Dali::Actor((const Dali::Actor &)result);
83060   return jresult;
83061 }
83062
83063
83064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83065   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83066   Dali::Actor arg2 ;
83067   Dali::Actor *argp2 ;
83068
83069   arg1 = (Dali::Toolkit::Popup *)jarg1;
83070   argp2 = (Dali::Actor *)jarg2;
83071   if (!argp2) {
83072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83073     return ;
83074   }
83075   arg2 = *argp2;
83076   {
83077     try {
83078       (arg1)->SetContent(arg2);
83079     } catch (std::out_of_range& e) {
83080       {
83081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83082       };
83083     } catch (std::exception& e) {
83084       {
83085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83086       };
83087     } catch (...) {
83088       {
83089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83090       };
83091     }
83092   }
83093 }
83094
83095
83096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83097   void * jresult ;
83098   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83099   Dali::Actor result;
83100
83101   arg1 = (Dali::Toolkit::Popup *)jarg1;
83102   {
83103     try {
83104       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83105     } catch (std::out_of_range& e) {
83106       {
83107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83108       };
83109     } catch (std::exception& e) {
83110       {
83111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83112       };
83113     } catch (...) {
83114       {
83115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83116       };
83117     }
83118   }
83119   jresult = new Dali::Actor((const Dali::Actor &)result);
83120   return jresult;
83121 }
83122
83123
83124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83125   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83126   Dali::Actor arg2 ;
83127   Dali::Actor *argp2 ;
83128
83129   arg1 = (Dali::Toolkit::Popup *)jarg1;
83130   argp2 = (Dali::Actor *)jarg2;
83131   if (!argp2) {
83132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83133     return ;
83134   }
83135   arg2 = *argp2;
83136   {
83137     try {
83138       (arg1)->SetFooter(arg2);
83139     } catch (std::out_of_range& e) {
83140       {
83141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83142       };
83143     } catch (std::exception& e) {
83144       {
83145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83146       };
83147     } catch (...) {
83148       {
83149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83150       };
83151     }
83152   }
83153 }
83154
83155
83156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83157   void * jresult ;
83158   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83159   Dali::Actor result;
83160
83161   arg1 = (Dali::Toolkit::Popup *)jarg1;
83162   {
83163     try {
83164       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83165     } catch (std::out_of_range& e) {
83166       {
83167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (std::exception& e) {
83170       {
83171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83172       };
83173     } catch (...) {
83174       {
83175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83176       };
83177     }
83178   }
83179   jresult = new Dali::Actor((const Dali::Actor &)result);
83180   return jresult;
83181 }
83182
83183
83184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83185   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83186   Dali::Toolkit::Popup::DisplayState arg2 ;
83187
83188   arg1 = (Dali::Toolkit::Popup *)jarg1;
83189   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83190   {
83191     try {
83192       (arg1)->SetDisplayState(arg2);
83193     } catch (std::out_of_range& e) {
83194       {
83195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83196       };
83197     } catch (std::exception& e) {
83198       {
83199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83200       };
83201     } catch (...) {
83202       {
83203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83204       };
83205     }
83206   }
83207 }
83208
83209
83210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83211   int jresult ;
83212   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83213   Dali::Toolkit::Popup::DisplayState result;
83214
83215   arg1 = (Dali::Toolkit::Popup *)jarg1;
83216   {
83217     try {
83218       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83219     } catch (std::out_of_range& e) {
83220       {
83221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83222       };
83223     } catch (std::exception& e) {
83224       {
83225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83226       };
83227     } catch (...) {
83228       {
83229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83230       };
83231     }
83232   }
83233   jresult = (int)result;
83234   return jresult;
83235 }
83236
83237
83238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83239   void * jresult ;
83240   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83241   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83242
83243   arg1 = (Dali::Toolkit::Popup *)jarg1;
83244   {
83245     try {
83246       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83247     } catch (std::out_of_range& e) {
83248       {
83249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83250       };
83251     } catch (std::exception& e) {
83252       {
83253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83254       };
83255     } catch (...) {
83256       {
83257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83258       };
83259     }
83260   }
83261   jresult = (void *)result;
83262   return jresult;
83263 }
83264
83265
83266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83267   void * jresult ;
83268   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83269   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83270
83271   arg1 = (Dali::Toolkit::Popup *)jarg1;
83272   {
83273     try {
83274       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83275     } catch (std::out_of_range& e) {
83276       {
83277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83278       };
83279     } catch (std::exception& e) {
83280       {
83281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83282       };
83283     } catch (...) {
83284       {
83285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83286       };
83287     }
83288   }
83289   jresult = (void *)result;
83290   return jresult;
83291 }
83292
83293
83294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83295   void * jresult ;
83296   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83297   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83298
83299   arg1 = (Dali::Toolkit::Popup *)jarg1;
83300   {
83301     try {
83302       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (...) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83314       };
83315     }
83316   }
83317   jresult = (void *)result;
83318   return jresult;
83319 }
83320
83321
83322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83323   void * jresult ;
83324   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83325   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83326
83327   arg1 = (Dali::Toolkit::Popup *)jarg1;
83328   {
83329     try {
83330       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83331     } catch (std::out_of_range& e) {
83332       {
83333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83334       };
83335     } catch (std::exception& e) {
83336       {
83337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83338       };
83339     } catch (...) {
83340       {
83341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83342       };
83343     }
83344   }
83345   jresult = (void *)result;
83346   return jresult;
83347 }
83348
83349
83350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83351   void * jresult ;
83352   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83353   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83354
83355   arg1 = (Dali::Toolkit::Popup *)jarg1;
83356   {
83357     try {
83358       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83359     } catch (std::out_of_range& e) {
83360       {
83361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83362       };
83363     } catch (std::exception& e) {
83364       {
83365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83366       };
83367     } catch (...) {
83368       {
83369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83370       };
83371     }
83372   }
83373   jresult = (void *)result;
83374   return jresult;
83375 }
83376
83377
83378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83379   int jresult ;
83380   int result;
83381
83382   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83383   jresult = (int)result;
83384   return jresult;
83385 }
83386
83387
83388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83389   int jresult ;
83390   int result;
83391
83392   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83393   jresult = (int)result;
83394   return jresult;
83395 }
83396
83397
83398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83399   int jresult ;
83400   int result;
83401
83402   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83403   jresult = (int)result;
83404   return jresult;
83405 }
83406
83407
83408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83409   int jresult ;
83410   int result;
83411
83412   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83413   jresult = (int)result;
83414   return jresult;
83415 }
83416
83417
83418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83419   int jresult ;
83420   int result;
83421
83422   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83423   jresult = (int)result;
83424   return jresult;
83425 }
83426
83427
83428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83429   int jresult ;
83430   int result;
83431
83432   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83433   jresult = (int)result;
83434   return jresult;
83435 }
83436
83437
83438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83439   int jresult ;
83440   int result;
83441
83442   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83443   jresult = (int)result;
83444   return jresult;
83445 }
83446
83447
83448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83449   int jresult ;
83450   int result;
83451
83452   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83453   jresult = (int)result;
83454   return jresult;
83455 }
83456
83457
83458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83459   int jresult ;
83460   int result;
83461
83462   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83463   jresult = (int)result;
83464   return jresult;
83465 }
83466
83467
83468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83469   void * jresult ;
83470   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83471
83472   {
83473     try {
83474       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (...) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83486       };
83487     }
83488   }
83489   jresult = (void *)result;
83490   return jresult;
83491 }
83492
83493
83494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83495   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83496
83497   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83498   {
83499     try {
83500       delete arg1;
83501     } catch (std::out_of_range& e) {
83502       {
83503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83504       };
83505     } catch (std::exception& e) {
83506       {
83507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83508       };
83509     } catch (...) {
83510       {
83511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83512       };
83513     }
83514   }
83515 }
83516
83517
83518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83519   void * jresult ;
83520   Dali::Toolkit::ProgressBar result;
83521
83522   {
83523     try {
83524       result = Dali::Toolkit::ProgressBar::New();
83525     } catch (std::out_of_range& e) {
83526       {
83527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83528       };
83529     } catch (std::exception& e) {
83530       {
83531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (...) {
83534       {
83535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83536       };
83537     }
83538   }
83539   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83540   return jresult;
83541 }
83542
83543
83544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83545   void * jresult ;
83546   Dali::Toolkit::ProgressBar *result = 0 ;
83547
83548   {
83549     try {
83550       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83551     } catch (std::out_of_range& e) {
83552       {
83553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83554       };
83555     } catch (std::exception& e) {
83556       {
83557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83558       };
83559     } catch (...) {
83560       {
83561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83562       };
83563     }
83564   }
83565   jresult = (void *)result;
83566   return jresult;
83567 }
83568
83569
83570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83571   void * jresult ;
83572   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83573   Dali::Toolkit::ProgressBar *result = 0 ;
83574
83575   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83576   if (!arg1) {
83577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83578     return 0;
83579   }
83580   {
83581     try {
83582       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83583     } catch (std::out_of_range& e) {
83584       {
83585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83586       };
83587     } catch (std::exception& e) {
83588       {
83589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83590       };
83591     } catch (...) {
83592       {
83593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83594       };
83595     }
83596   }
83597   jresult = (void *)result;
83598   return jresult;
83599 }
83600
83601
83602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83603   void * jresult ;
83604   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83605   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83606   Dali::Toolkit::ProgressBar *result = 0 ;
83607
83608   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83609   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83610   if (!arg2) {
83611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83612     return 0;
83613   }
83614   {
83615     try {
83616       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83617     } catch (std::out_of_range& e) {
83618       {
83619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83620       };
83621     } catch (std::exception& e) {
83622       {
83623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (...) {
83626       {
83627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83628       };
83629     }
83630   }
83631   jresult = (void *)result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83637   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83638
83639   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83640   {
83641     try {
83642       delete arg1;
83643     } catch (std::out_of_range& e) {
83644       {
83645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83646       };
83647     } catch (std::exception& e) {
83648       {
83649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83654       };
83655     }
83656   }
83657 }
83658
83659
83660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83661   void * jresult ;
83662   Dali::BaseHandle arg1 ;
83663   Dali::BaseHandle *argp1 ;
83664   Dali::Toolkit::ProgressBar result;
83665
83666   argp1 = (Dali::BaseHandle *)jarg1;
83667   if (!argp1) {
83668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83669     return 0;
83670   }
83671   arg1 = *argp1;
83672   {
83673     try {
83674       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83675     } catch (std::out_of_range& e) {
83676       {
83677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (std::exception& e) {
83680       {
83681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83682       };
83683     } catch (...) {
83684       {
83685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83686       };
83687     }
83688   }
83689   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83690   return jresult;
83691 }
83692
83693
83694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83695   void * jresult ;
83696   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83697   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83698
83699   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83700   {
83701     try {
83702       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83703     } catch (std::out_of_range& e) {
83704       {
83705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (std::exception& e) {
83708       {
83709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (...) {
83712       {
83713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83714       };
83715     }
83716   }
83717   jresult = (void *)result;
83718   return jresult;
83719 }
83720
83721
83722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83723   void * jresult ;
83724   Dali::Toolkit::GaussianBlurView *result = 0 ;
83725
83726   {
83727     try {
83728       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83729     } catch (std::out_of_range& e) {
83730       {
83731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83732       };
83733     } catch (std::exception& e) {
83734       {
83735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83736       };
83737     } catch (...) {
83738       {
83739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83740       };
83741     }
83742   }
83743   jresult = (void *)result;
83744   return jresult;
83745 }
83746
83747
83748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83749   void * jresult ;
83750   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83751   Dali::Toolkit::GaussianBlurView *result = 0 ;
83752
83753   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83754   if (!arg1) {
83755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83756     return 0;
83757   }
83758   {
83759     try {
83760       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83761     } catch (std::out_of_range& e) {
83762       {
83763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83764       };
83765     } catch (std::exception& e) {
83766       {
83767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83772       };
83773     }
83774   }
83775   jresult = (void *)result;
83776   return jresult;
83777 }
83778
83779
83780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83781   void * jresult ;
83782   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83783   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83784   Dali::Toolkit::GaussianBlurView *result = 0 ;
83785
83786   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83787   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83788   if (!arg2) {
83789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83790     return 0;
83791   }
83792   {
83793     try {
83794       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83795     } catch (std::out_of_range& e) {
83796       {
83797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (std::exception& e) {
83800       {
83801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83806       };
83807     }
83808   }
83809   jresult = (void *)result;
83810   return jresult;
83811 }
83812
83813
83814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83815   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83816
83817   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83818   {
83819     try {
83820       delete arg1;
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (...) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83832       };
83833     }
83834   }
83835 }
83836
83837
83838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83839   void * jresult ;
83840   Dali::BaseHandle arg1 ;
83841   Dali::BaseHandle *argp1 ;
83842   Dali::Toolkit::GaussianBlurView result;
83843
83844   argp1 = (Dali::BaseHandle *)jarg1;
83845   if (!argp1) {
83846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83847     return 0;
83848   }
83849   arg1 = *argp1;
83850   {
83851     try {
83852       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83853     } catch (std::out_of_range& e) {
83854       {
83855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83856       };
83857     } catch (std::exception& e) {
83858       {
83859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (...) {
83862       {
83863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83864       };
83865     }
83866   }
83867   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83868   return jresult;
83869 }
83870
83871
83872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83873   void * jresult ;
83874   Dali::Toolkit::GaussianBlurView result;
83875
83876   {
83877     try {
83878       result = Dali::Toolkit::GaussianBlurView::New();
83879     } catch (std::out_of_range& e) {
83880       {
83881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (std::exception& e) {
83884       {
83885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83886       };
83887     } catch (...) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83890       };
83891     }
83892   }
83893   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83894   return jresult;
83895 }
83896
83897
83898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83899   void * jresult ;
83900   unsigned int arg1 ;
83901   float arg2 ;
83902   Dali::Pixel::Format arg3 ;
83903   float arg4 ;
83904   float arg5 ;
83905   bool arg6 ;
83906   Dali::Toolkit::GaussianBlurView result;
83907
83908   arg1 = (unsigned int)jarg1;
83909   arg2 = (float)jarg2;
83910   arg3 = (Dali::Pixel::Format)jarg3;
83911   arg4 = (float)jarg4;
83912   arg5 = (float)jarg5;
83913   arg6 = jarg6 ? true : false;
83914   {
83915     try {
83916       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83917     } catch (std::out_of_range& e) {
83918       {
83919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (std::exception& e) {
83922       {
83923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83928       };
83929     }
83930   }
83931   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83932   return jresult;
83933 }
83934
83935
83936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83937   void * jresult ;
83938   unsigned int arg1 ;
83939   float arg2 ;
83940   Dali::Pixel::Format arg3 ;
83941   float arg4 ;
83942   float arg5 ;
83943   Dali::Toolkit::GaussianBlurView result;
83944
83945   arg1 = (unsigned int)jarg1;
83946   arg2 = (float)jarg2;
83947   arg3 = (Dali::Pixel::Format)jarg3;
83948   arg4 = (float)jarg4;
83949   arg5 = (float)jarg5;
83950   {
83951     try {
83952       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (...) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83964       };
83965     }
83966   }
83967   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83968   return jresult;
83969 }
83970
83971
83972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83973   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83974   Dali::Actor arg2 ;
83975   Dali::Actor *argp2 ;
83976
83977   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83978   argp2 = (Dali::Actor *)jarg2;
83979   if (!argp2) {
83980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83981     return ;
83982   }
83983   arg2 = *argp2;
83984   {
83985     try {
83986       (arg1)->Add(arg2);
83987     } catch (std::out_of_range& e) {
83988       {
83989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83990       };
83991     } catch (std::exception& e) {
83992       {
83993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83994       };
83995     } catch (...) {
83996       {
83997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83998       };
83999     }
84000   }
84001 }
84002
84003
84004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84005   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84006   Dali::Actor arg2 ;
84007   Dali::Actor *argp2 ;
84008
84009   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84010   argp2 = (Dali::Actor *)jarg2;
84011   if (!argp2) {
84012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84013     return ;
84014   }
84015   arg2 = *argp2;
84016   {
84017     try {
84018       (arg1)->Remove(arg2);
84019     } catch (std::out_of_range& e) {
84020       {
84021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84022       };
84023     } catch (std::exception& e) {
84024       {
84025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84026       };
84027     } catch (...) {
84028       {
84029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84030       };
84031     }
84032   }
84033 }
84034
84035
84036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84037   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84038
84039   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84040   {
84041     try {
84042       (arg1)->Activate();
84043     } catch (std::out_of_range& e) {
84044       {
84045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84046       };
84047     } catch (std::exception& e) {
84048       {
84049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84054       };
84055     }
84056   }
84057 }
84058
84059
84060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84061   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84062
84063   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84064   {
84065     try {
84066       (arg1)->ActivateOnce();
84067     } catch (std::out_of_range& e) {
84068       {
84069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84070       };
84071     } catch (std::exception& e) {
84072       {
84073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84074       };
84075     } catch (...) {
84076       {
84077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84078       };
84079     }
84080   }
84081 }
84082
84083
84084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84085   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84086
84087   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84088   {
84089     try {
84090       (arg1)->Deactivate();
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84102       };
84103     }
84104   }
84105 }
84106
84107
84108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84109   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84110   Dali::Image arg2 ;
84111   Dali::FrameBufferImage arg3 ;
84112   Dali::Image *argp2 ;
84113   Dali::FrameBufferImage *argp3 ;
84114
84115   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84116   argp2 = (Dali::Image *)jarg2;
84117   if (!argp2) {
84118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84119     return ;
84120   }
84121   arg2 = *argp2;
84122   argp3 = (Dali::FrameBufferImage *)jarg3;
84123   if (!argp3) {
84124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84125     return ;
84126   }
84127   arg3 = *argp3;
84128   {
84129     try {
84130       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84131     } catch (std::out_of_range& e) {
84132       {
84133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84134       };
84135     } catch (std::exception& e) {
84136       {
84137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84138       };
84139     } catch (...) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84142       };
84143     }
84144   }
84145 }
84146
84147
84148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84149   int jresult ;
84150   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84151   Dali::Property::Index result;
84152
84153   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84154   {
84155     try {
84156       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84157     } catch (std::out_of_range& e) {
84158       {
84159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84160       };
84161     } catch (std::exception& e) {
84162       {
84163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84164       };
84165     } catch (...) {
84166       {
84167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84168       };
84169     }
84170   }
84171   jresult = result;
84172   return jresult;
84173 }
84174
84175
84176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84177   void * jresult ;
84178   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84179   Dali::FrameBufferImage result;
84180
84181   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84182   {
84183     try {
84184       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84185     } catch (std::out_of_range& e) {
84186       {
84187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84188       };
84189     } catch (std::exception& e) {
84190       {
84191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84196       };
84197     }
84198   }
84199   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84205   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84206   Dali::Vector4 *arg2 = 0 ;
84207
84208   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84209   arg2 = (Dali::Vector4 *)jarg2;
84210   if (!arg2) {
84211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84212     return ;
84213   }
84214   {
84215     try {
84216       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84217     } catch (std::out_of_range& e) {
84218       {
84219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84220       };
84221     } catch (std::exception& e) {
84222       {
84223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84228       };
84229     }
84230   }
84231 }
84232
84233
84234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84235   void * jresult ;
84236   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84237   Dali::Vector4 result;
84238
84239   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84240   {
84241     try {
84242       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84243     } catch (std::out_of_range& e) {
84244       {
84245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84246       };
84247     } catch (std::exception& e) {
84248       {
84249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84250       };
84251     } catch (...) {
84252       {
84253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84254       };
84255     }
84256   }
84257   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84258   return jresult;
84259 }
84260
84261
84262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84263   void * jresult ;
84264   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84265   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84266
84267   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84268   {
84269     try {
84270       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84271     } catch (std::out_of_range& e) {
84272       {
84273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84274       };
84275     } catch (std::exception& e) {
84276       {
84277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84278       };
84279     } catch (...) {
84280       {
84281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84282       };
84283     }
84284   }
84285   jresult = (void *)result;
84286   return jresult;
84287 }
84288
84289
84290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84291   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84292
84293   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84294   {
84295     try {
84296       delete arg1;
84297     } catch (std::out_of_range& e) {
84298       {
84299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84300       };
84301     } catch (std::exception& e) {
84302       {
84303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84304       };
84305     } catch (...) {
84306       {
84307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84308       };
84309     }
84310   }
84311 }
84312
84313
84314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84315   unsigned int jresult ;
84316   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84317   unsigned int result;
84318
84319   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84320   {
84321     try {
84322       result = (unsigned int)(arg1)->GetNumberOfPages();
84323     } catch (std::out_of_range& e) {
84324       {
84325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84326       };
84327     } catch (std::exception& e) {
84328       {
84329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (...) {
84332       {
84333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84334       };
84335     }
84336   }
84337   jresult = result;
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84343   void * jresult ;
84344   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84345   unsigned int arg2 ;
84346   Dali::Texture result;
84347
84348   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84349   arg2 = (unsigned int)jarg2;
84350   {
84351     try {
84352       result = (arg1)->NewPage(arg2);
84353     } catch (std::out_of_range& e) {
84354       {
84355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84356       };
84357     } catch (std::exception& e) {
84358       {
84359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84360       };
84361     } catch (...) {
84362       {
84363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84364       };
84365     }
84366   }
84367   jresult = new Dali::Texture((const Dali::Texture &)result);
84368   return jresult;
84369 }
84370
84371
84372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84373   int jresult ;
84374   int result;
84375
84376   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84377   jresult = (int)result;
84378   return jresult;
84379 }
84380
84381
84382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84383   int jresult ;
84384   int result;
84385
84386   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84387   jresult = (int)result;
84388   return jresult;
84389 }
84390
84391
84392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84393   int jresult ;
84394   int result;
84395
84396   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84397   jresult = (int)result;
84398   return jresult;
84399 }
84400
84401
84402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84403   void * jresult ;
84404   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84405
84406   {
84407     try {
84408       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84409     } catch (std::out_of_range& e) {
84410       {
84411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84412       };
84413     } catch (std::exception& e) {
84414       {
84415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84416       };
84417     } catch (...) {
84418       {
84419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84420       };
84421     }
84422   }
84423   jresult = (void *)result;
84424   return jresult;
84425 }
84426
84427
84428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84429   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84430
84431   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84432   {
84433     try {
84434       delete arg1;
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84446       };
84447     }
84448   }
84449 }
84450
84451
84452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84453   void * jresult ;
84454   Dali::Toolkit::PageTurnView *result = 0 ;
84455
84456   {
84457     try {
84458       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84459     } catch (std::out_of_range& e) {
84460       {
84461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84462       };
84463     } catch (std::exception& e) {
84464       {
84465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84466       };
84467     } catch (...) {
84468       {
84469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84470       };
84471     }
84472   }
84473   jresult = (void *)result;
84474   return jresult;
84475 }
84476
84477
84478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84479   void * jresult ;
84480   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84481   Dali::Toolkit::PageTurnView *result = 0 ;
84482
84483   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84484   if (!arg1) {
84485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84486     return 0;
84487   }
84488   {
84489     try {
84490       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84491     } catch (std::out_of_range& e) {
84492       {
84493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (std::exception& e) {
84496       {
84497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84498       };
84499     } catch (...) {
84500       {
84501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84502       };
84503     }
84504   }
84505   jresult = (void *)result;
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84511   void * jresult ;
84512   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84513   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84514   Dali::Toolkit::PageTurnView *result = 0 ;
84515
84516   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84517   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84518   if (!arg2) {
84519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84520     return 0;
84521   }
84522   {
84523     try {
84524       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84525     } catch (std::out_of_range& e) {
84526       {
84527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84528       };
84529     } catch (std::exception& e) {
84530       {
84531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84532       };
84533     } catch (...) {
84534       {
84535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84536       };
84537     }
84538   }
84539   jresult = (void *)result;
84540   return jresult;
84541 }
84542
84543
84544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84545   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84546
84547   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84548   {
84549     try {
84550       delete arg1;
84551     } catch (std::out_of_range& e) {
84552       {
84553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84554       };
84555     } catch (std::exception& e) {
84556       {
84557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84558       };
84559     } catch (...) {
84560       {
84561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84562       };
84563     }
84564   }
84565 }
84566
84567
84568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84569   void * jresult ;
84570   Dali::BaseHandle arg1 ;
84571   Dali::BaseHandle *argp1 ;
84572   Dali::Toolkit::PageTurnView result;
84573
84574   argp1 = (Dali::BaseHandle *)jarg1;
84575   if (!argp1) {
84576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84577     return 0;
84578   }
84579   arg1 = *argp1;
84580   {
84581     try {
84582       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84583     } catch (std::out_of_range& e) {
84584       {
84585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (std::exception& e) {
84588       {
84589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84590       };
84591     } catch (...) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84594       };
84595     }
84596   }
84597   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84598   return jresult;
84599 }
84600
84601
84602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84603   void * jresult ;
84604   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84605   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84606
84607   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84608   {
84609     try {
84610       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84611     } catch (std::out_of_range& e) {
84612       {
84613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84614       };
84615     } catch (std::exception& e) {
84616       {
84617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84622       };
84623     }
84624   }
84625   jresult = (void *)result;
84626   return jresult;
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84631   void * jresult ;
84632   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84633   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84634
84635   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84636   {
84637     try {
84638       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (...) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84650       };
84651     }
84652   }
84653   jresult = (void *)result;
84654   return jresult;
84655 }
84656
84657
84658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84659   void * jresult ;
84660   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84661   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84662
84663   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84664   {
84665     try {
84666       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84667     } catch (std::out_of_range& e) {
84668       {
84669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84670       };
84671     } catch (std::exception& e) {
84672       {
84673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (...) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84678       };
84679     }
84680   }
84681   jresult = (void *)result;
84682   return jresult;
84683 }
84684
84685
84686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84687   void * jresult ;
84688   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84689   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84690
84691   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84692   {
84693     try {
84694       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84695     } catch (std::out_of_range& e) {
84696       {
84697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (std::exception& e) {
84700       {
84701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84702       };
84703     } catch (...) {
84704       {
84705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84706       };
84707     }
84708   }
84709   jresult = (void *)result;
84710   return jresult;
84711 }
84712
84713
84714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84715   void * jresult ;
84716   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84717
84718   {
84719     try {
84720       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84721     } catch (std::out_of_range& e) {
84722       {
84723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84724       };
84725     } catch (std::exception& e) {
84726       {
84727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84728       };
84729     } catch (...) {
84730       {
84731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84732       };
84733     }
84734   }
84735   jresult = (void *)result;
84736   return jresult;
84737 }
84738
84739
84740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84741   void * jresult ;
84742   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84743   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84744
84745   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84746   if (!arg1) {
84747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84748     return 0;
84749   }
84750   {
84751     try {
84752       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84753     } catch (std::out_of_range& e) {
84754       {
84755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84756       };
84757     } catch (std::exception& e) {
84758       {
84759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84764       };
84765     }
84766   }
84767   jresult = (void *)result;
84768   return jresult;
84769 }
84770
84771
84772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84773   void * jresult ;
84774   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84775   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84776   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84777
84778   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84779   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84780   if (!arg2) {
84781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84782     return 0;
84783   }
84784   {
84785     try {
84786       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (...) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84798       };
84799     }
84800   }
84801   jresult = (void *)result;
84802   return jresult;
84803 }
84804
84805
84806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84807   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84808
84809   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84810   {
84811     try {
84812       delete arg1;
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84824       };
84825     }
84826   }
84827 }
84828
84829
84830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84831   void * jresult ;
84832   Dali::Toolkit::PageFactory *arg1 = 0 ;
84833   Dali::Vector2 *arg2 = 0 ;
84834   Dali::Toolkit::PageTurnLandscapeView result;
84835
84836   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84837   if (!arg1) {
84838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84839     return 0;
84840   }
84841   arg2 = (Dali::Vector2 *)jarg2;
84842   if (!arg2) {
84843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84844     return 0;
84845   }
84846   {
84847     try {
84848       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84849     } catch (std::out_of_range& e) {
84850       {
84851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84852       };
84853     } catch (std::exception& e) {
84854       {
84855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84856       };
84857     } catch (...) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84860       };
84861     }
84862   }
84863   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84869   void * jresult ;
84870   Dali::BaseHandle arg1 ;
84871   Dali::BaseHandle *argp1 ;
84872   Dali::Toolkit::PageTurnLandscapeView result;
84873
84874   argp1 = (Dali::BaseHandle *)jarg1;
84875   if (!argp1) {
84876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84877     return 0;
84878   }
84879   arg1 = *argp1;
84880   {
84881     try {
84882       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84883     } catch (std::out_of_range& e) {
84884       {
84885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (std::exception& e) {
84888       {
84889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84898   return jresult;
84899 }
84900
84901
84902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84903   void * jresult ;
84904   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84905
84906   {
84907     try {
84908       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84909     } catch (std::out_of_range& e) {
84910       {
84911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84912       };
84913     } catch (std::exception& e) {
84914       {
84915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84916       };
84917     } catch (...) {
84918       {
84919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84920       };
84921     }
84922   }
84923   jresult = (void *)result;
84924   return jresult;
84925 }
84926
84927
84928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84929   void * jresult ;
84930   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84931   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84932
84933   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84934   if (!arg1) {
84935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84936     return 0;
84937   }
84938   {
84939     try {
84940       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84941     } catch (std::out_of_range& e) {
84942       {
84943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84944       };
84945     } catch (std::exception& e) {
84946       {
84947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84948       };
84949     } catch (...) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84952       };
84953     }
84954   }
84955   jresult = (void *)result;
84956   return jresult;
84957 }
84958
84959
84960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84961   void * jresult ;
84962   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84963   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84964   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84965
84966   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84967   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84968   if (!arg2) {
84969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84970     return 0;
84971   }
84972   {
84973     try {
84974       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84975     } catch (std::out_of_range& e) {
84976       {
84977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (std::exception& e) {
84980       {
84981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84982       };
84983     } catch (...) {
84984       {
84985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84986       };
84987     }
84988   }
84989   jresult = (void *)result;
84990   return jresult;
84991 }
84992
84993
84994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84995   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84996
84997   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84998   {
84999     try {
85000       delete arg1;
85001     } catch (std::out_of_range& e) {
85002       {
85003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85004       };
85005     } catch (std::exception& e) {
85006       {
85007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85008       };
85009     } catch (...) {
85010       {
85011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85012       };
85013     }
85014   }
85015 }
85016
85017
85018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85019   void * jresult ;
85020   Dali::Toolkit::PageFactory *arg1 = 0 ;
85021   Dali::Vector2 *arg2 = 0 ;
85022   Dali::Toolkit::PageTurnPortraitView result;
85023
85024   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85025   if (!arg1) {
85026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85027     return 0;
85028   }
85029   arg2 = (Dali::Vector2 *)jarg2;
85030   if (!arg2) {
85031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85032     return 0;
85033   }
85034   {
85035     try {
85036       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85037     } catch (std::out_of_range& e) {
85038       {
85039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85040       };
85041     } catch (std::exception& e) {
85042       {
85043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85044       };
85045     } catch (...) {
85046       {
85047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85048       };
85049     }
85050   }
85051   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85052   return jresult;
85053 }
85054
85055
85056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85057   void * jresult ;
85058   Dali::BaseHandle arg1 ;
85059   Dali::BaseHandle *argp1 ;
85060   Dali::Toolkit::PageTurnPortraitView result;
85061
85062   argp1 = (Dali::BaseHandle *)jarg1;
85063   if (!argp1) {
85064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85065     return 0;
85066   }
85067   arg1 = *argp1;
85068   {
85069     try {
85070       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85071     } catch (std::out_of_range& e) {
85072       {
85073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85074       };
85075     } catch (std::exception& e) {
85076       {
85077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85078       };
85079     } catch (...) {
85080       {
85081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85082       };
85083     }
85084   }
85085   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85086   return jresult;
85087 }
85088
85089
85090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85091   int jresult ;
85092   int result;
85093
85094   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85095   jresult = (int)result;
85096   return jresult;
85097 }
85098
85099
85100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85101   int jresult ;
85102   int result;
85103
85104   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85105   jresult = (int)result;
85106   return jresult;
85107 }
85108
85109
85110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85111   int jresult ;
85112   int result;
85113
85114   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85115   jresult = (int)result;
85116   return jresult;
85117 }
85118
85119
85120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85121   void * jresult ;
85122   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85123
85124   {
85125     try {
85126       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85127     } catch (std::out_of_range& e) {
85128       {
85129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85130       };
85131     } catch (std::exception& e) {
85132       {
85133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85138       };
85139     }
85140   }
85141   jresult = (void *)result;
85142   return jresult;
85143 }
85144
85145
85146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85147   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85148
85149   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85150   {
85151     try {
85152       delete arg1;
85153     } catch (std::out_of_range& e) {
85154       {
85155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85156       };
85157     } catch (std::exception& e) {
85158       {
85159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85164       };
85165     }
85166   }
85167 }
85168
85169
85170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85171   void * jresult ;
85172   Dali::Toolkit::ToggleButton *result = 0 ;
85173
85174   {
85175     try {
85176       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85177     } catch (std::out_of_range& e) {
85178       {
85179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (std::exception& e) {
85182       {
85183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (...) {
85186       {
85187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85188       };
85189     }
85190   }
85191   jresult = (void *)result;
85192   return jresult;
85193 }
85194
85195
85196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85197   void * jresult ;
85198   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85199   Dali::Toolkit::ToggleButton *result = 0 ;
85200
85201   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85202   if (!arg1) {
85203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85204     return 0;
85205   }
85206   {
85207     try {
85208       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223   jresult = (void *)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85229   void * jresult ;
85230   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85231   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85232   Dali::Toolkit::ToggleButton *result = 0 ;
85233
85234   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85235   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85236   if (!arg2) {
85237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85238     return 0;
85239   }
85240   {
85241     try {
85242       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85243     } catch (std::out_of_range& e) {
85244       {
85245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85246       };
85247     } catch (std::exception& e) {
85248       {
85249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85250       };
85251     } catch (...) {
85252       {
85253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85254       };
85255     }
85256   }
85257   jresult = (void *)result;
85258   return jresult;
85259 }
85260
85261
85262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85263   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85264
85265   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85266   {
85267     try {
85268       delete arg1;
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85276       };
85277     } catch (...) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85280       };
85281     }
85282   }
85283 }
85284
85285
85286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85287   void * jresult ;
85288   Dali::Toolkit::ToggleButton result;
85289
85290   {
85291     try {
85292       result = Dali::Toolkit::ToggleButton::New();
85293     } catch (std::out_of_range& e) {
85294       {
85295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85296       };
85297     } catch (std::exception& e) {
85298       {
85299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (...) {
85302       {
85303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85304       };
85305     }
85306   }
85307   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85313   void * jresult ;
85314   Dali::BaseHandle arg1 ;
85315   Dali::BaseHandle *argp1 ;
85316   Dali::Toolkit::ToggleButton result;
85317
85318   argp1 = (Dali::BaseHandle *)jarg1;
85319   if (!argp1) {
85320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85321     return 0;
85322   }
85323   arg1 = *argp1;
85324   {
85325     try {
85326       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85327     } catch (std::out_of_range& e) {
85328       {
85329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (std::exception& e) {
85332       {
85333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (...) {
85336       {
85337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85338       };
85339     }
85340   }
85341   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85342   return jresult;
85343 }
85344
85345
85346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85347   void * jresult ;
85348   Dali::Toolkit::Visual::Base *result = 0 ;
85349
85350   {
85351     try {
85352       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85353     } catch (std::out_of_range& e) {
85354       {
85355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (std::exception& e) {
85358       {
85359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85364       };
85365     }
85366   }
85367   jresult = (void *)result;
85368   return jresult;
85369 }
85370
85371
85372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85373   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85374
85375   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85376   {
85377     try {
85378       delete arg1;
85379     } catch (std::out_of_range& e) {
85380       {
85381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85382       };
85383     } catch (std::exception& e) {
85384       {
85385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85386       };
85387     } catch (...) {
85388       {
85389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85390       };
85391     }
85392   }
85393 }
85394
85395
85396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85397   void * jresult ;
85398   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85399   Dali::Toolkit::Visual::Base *result = 0 ;
85400
85401   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85402   if (!arg1) {
85403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85404     return 0;
85405   }
85406   {
85407     try {
85408       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85409     } catch (std::out_of_range& e) {
85410       {
85411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85412       };
85413     } catch (std::exception& e) {
85414       {
85415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85416       };
85417     } catch (...) {
85418       {
85419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85420       };
85421     }
85422   }
85423   jresult = (void *)result;
85424   return jresult;
85425 }
85426
85427
85428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85429   void * jresult ;
85430   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85431   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85432   Dali::Toolkit::Visual::Base *result = 0 ;
85433
85434   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85435   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85436   if (!arg2) {
85437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85438     return 0;
85439   }
85440   {
85441     try {
85442       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85443     } catch (std::out_of_range& e) {
85444       {
85445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (std::exception& e) {
85448       {
85449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85450       };
85451     } catch (...) {
85452       {
85453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85454       };
85455     }
85456   }
85457   jresult = (void *)result;
85458   return jresult;
85459 }
85460
85461
85462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85463   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85464   std::string *arg2 = 0 ;
85465
85466   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85467   if (!jarg2) {
85468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85469     return ;
85470   }
85471   std::string arg2_str(jarg2);
85472   arg2 = &arg2_str;
85473   {
85474     try {
85475       (arg1)->SetName((std::string const &)*arg2);
85476     } catch (std::out_of_range& e) {
85477       {
85478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (std::exception& e) {
85481       {
85482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85487       };
85488     }
85489   }
85490
85491   //argout typemap for const std::string&
85492
85493 }
85494
85495
85496 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85497   char * jresult ;
85498   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85499   std::string *result = 0 ;
85500
85501   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85502   {
85503     try {
85504       result = (std::string *) &(arg1)->GetName();
85505     } catch (std::out_of_range& e) {
85506       {
85507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85508       };
85509     } catch (std::exception& e) {
85510       {
85511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85512       };
85513     } catch (...) {
85514       {
85515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85516       };
85517     }
85518   }
85519   jresult = SWIG_csharp_string_callback(result->c_str());
85520   return jresult;
85521 }
85522
85523
85524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85525   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85526   Dali::Property::Map *arg2 = 0 ;
85527   Dali::Size arg3 ;
85528   Dali::Size *argp3 ;
85529
85530   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85531   arg2 = (Dali::Property::Map *)jarg2;
85532   if (!arg2) {
85533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85534     return ;
85535   }
85536   argp3 = (Dali::Size *)jarg3;
85537   if (!argp3) {
85538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85539     return ;
85540   }
85541   arg3 = *argp3;
85542   {
85543     try {
85544       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85545     } catch (std::out_of_range& e) {
85546       {
85547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85548       };
85549     } catch (std::exception& e) {
85550       {
85551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85552       };
85553     } catch (...) {
85554       {
85555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85556       };
85557     }
85558   }
85559 }
85560
85561
85562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85563   float jresult ;
85564   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85565   float arg2 ;
85566   float result;
85567
85568   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85569   arg2 = (float)jarg2;
85570   {
85571     try {
85572       result = (float)(arg1)->GetHeightForWidth(arg2);
85573     } catch (std::out_of_range& e) {
85574       {
85575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85576       };
85577     } catch (std::exception& e) {
85578       {
85579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85580       };
85581     } catch (...) {
85582       {
85583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85584       };
85585     }
85586   }
85587   jresult = result;
85588   return jresult;
85589 }
85590
85591
85592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85593   float jresult ;
85594   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85595   float arg2 ;
85596   float result;
85597
85598   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85599   arg2 = (float)jarg2;
85600   {
85601     try {
85602       result = (float)(arg1)->GetWidthForHeight(arg2);
85603     } catch (std::out_of_range& e) {
85604       {
85605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85606       };
85607     } catch (std::exception& e) {
85608       {
85609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85610       };
85611     } catch (...) {
85612       {
85613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85614       };
85615     }
85616   }
85617   jresult = result;
85618   return jresult;
85619 }
85620
85621
85622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85623   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85624   Dali::Vector2 *arg2 = 0 ;
85625
85626   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85627   arg2 = (Dali::Vector2 *)jarg2;
85628   if (!arg2) {
85629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85630     return ;
85631   }
85632   {
85633     try {
85634       (arg1)->GetNaturalSize(*arg2);
85635     } catch (std::out_of_range& e) {
85636       {
85637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85638       };
85639     } catch (std::exception& e) {
85640       {
85641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85642       };
85643     } catch (...) {
85644       {
85645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85646       };
85647     }
85648   }
85649 }
85650
85651
85652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85653   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85654   float arg2 ;
85655
85656   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85657   arg2 = (float)jarg2;
85658   {
85659     try {
85660       (arg1)->SetDepthIndex(arg2);
85661     } catch (std::out_of_range& e) {
85662       {
85663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85664       };
85665     } catch (std::exception& e) {
85666       {
85667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85668       };
85669     } catch (...) {
85670       {
85671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85672       };
85673     }
85674   }
85675 }
85676
85677
85678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85679   float jresult ;
85680   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85681   float result;
85682
85683   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85684   {
85685     try {
85686       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85687     } catch (std::out_of_range& e) {
85688       {
85689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85690       };
85691     } catch (std::exception& e) {
85692       {
85693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85694       };
85695     } catch (...) {
85696       {
85697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85698       };
85699     }
85700   }
85701   jresult = result;
85702   return jresult;
85703 }
85704
85705
85706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85707   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85708   Dali::Property::Map *arg2 = 0 ;
85709
85710   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85711   arg2 = (Dali::Property::Map *)jarg2;
85712   if (!arg2) {
85713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85714     return ;
85715   }
85716   {
85717     try {
85718       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85719     } catch (std::out_of_range& e) {
85720       {
85721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85722       };
85723     } catch (std::exception& e) {
85724       {
85725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85726       };
85727     } catch (...) {
85728       {
85729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85730       };
85731     }
85732   }
85733 }
85734
85735
85736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85737   void * jresult ;
85738   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85739   Dali::Toolkit::Visual::Base *result = 0 ;
85740
85741   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85742   {
85743     try {
85744       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85745     } catch (std::out_of_range& e) {
85746       {
85747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85748       };
85749     } catch (std::exception& e) {
85750       {
85751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (...) {
85754       {
85755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85756       };
85757     }
85758   }
85759   jresult = (void *)result;
85760   return jresult;
85761 }
85762
85763
85764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85765   void * jresult ;
85766   Dali::Toolkit::VisualFactory result;
85767
85768   {
85769     try {
85770       result = Dali::Toolkit::VisualFactory::Get();
85771     } catch (std::out_of_range& e) {
85772       {
85773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85774       };
85775     } catch (std::exception& e) {
85776       {
85777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85778       };
85779     } catch (...) {
85780       {
85781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85782       };
85783     }
85784   }
85785   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85786   return jresult;
85787 }
85788
85789
85790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85791   void * jresult ;
85792   Dali::Toolkit::VisualFactory *result = 0 ;
85793
85794   {
85795     try {
85796       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85797     } catch (std::out_of_range& e) {
85798       {
85799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85800       };
85801     } catch (std::exception& e) {
85802       {
85803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85804       };
85805     } catch (...) {
85806       {
85807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85808       };
85809     }
85810   }
85811   jresult = (void *)result;
85812   return jresult;
85813 }
85814
85815
85816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85817   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85818
85819   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85820   {
85821     try {
85822       delete arg1;
85823     } catch (std::out_of_range& e) {
85824       {
85825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85826       };
85827     } catch (std::exception& e) {
85828       {
85829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85830       };
85831     } catch (...) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85834       };
85835     }
85836   }
85837 }
85838
85839
85840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85841   void * jresult ;
85842   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85843   Dali::Toolkit::VisualFactory *result = 0 ;
85844
85845   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85846   if (!arg1) {
85847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85848     return 0;
85849   }
85850   {
85851     try {
85852       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85853     } catch (std::out_of_range& e) {
85854       {
85855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85856       };
85857     } catch (std::exception& e) {
85858       {
85859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85860       };
85861     } catch (...) {
85862       {
85863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85864       };
85865     }
85866   }
85867   jresult = (void *)result;
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85873   void * jresult ;
85874   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85875   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85876   Dali::Toolkit::VisualFactory *result = 0 ;
85877
85878   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85879   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85880   if (!arg2) {
85881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85882     return 0;
85883   }
85884   {
85885     try {
85886       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
85887     } catch (std::out_of_range& e) {
85888       {
85889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (std::exception& e) {
85892       {
85893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901   jresult = (void *)result;
85902   return jresult;
85903 }
85904
85905
85906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85907   void * jresult ;
85908   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85909   Dali::Property::Map *arg2 = 0 ;
85910   Dali::Toolkit::Visual::Base result;
85911
85912   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85913   arg2 = (Dali::Property::Map *)jarg2;
85914   if (!arg2) {
85915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85916     return 0;
85917   }
85918   {
85919     try {
85920       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85921     } catch (std::out_of_range& e) {
85922       {
85923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85924       };
85925     } catch (std::exception& e) {
85926       {
85927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85928       };
85929     } catch (...) {
85930       {
85931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85932       };
85933     }
85934   }
85935   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85936   return jresult;
85937 }
85938
85939
85940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
85941   void * jresult ;
85942   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85943   Dali::Image *arg2 = 0 ;
85944   Dali::Toolkit::Visual::Base result;
85945
85946   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85947   arg2 = (Dali::Image *)jarg2;
85948   if (!arg2) {
85949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
85950     return 0;
85951   }
85952   {
85953     try {
85954       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
85955     } catch (std::out_of_range& e) {
85956       {
85957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85958       };
85959     } catch (std::exception& e) {
85960       {
85961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (...) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85966       };
85967     }
85968   }
85969   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85970   return jresult;
85971 }
85972
85973
85974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85975   void * jresult ;
85976   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85977   std::string *arg2 = 0 ;
85978   Dali::ImageDimensions arg3 ;
85979   Dali::ImageDimensions *argp3 ;
85980   Dali::Toolkit::Visual::Base result;
85981
85982   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85983   if (!jarg2) {
85984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85985     return 0;
85986   }
85987   std::string arg2_str(jarg2);
85988   arg2 = &arg2_str;
85989   argp3 = (Dali::ImageDimensions *)jarg3;
85990   if (!argp3) {
85991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85992     return 0;
85993   }
85994   arg3 = *argp3;
85995   {
85996     try {
85997       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85998     } catch (std::out_of_range& e) {
85999       {
86000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (std::exception& e) {
86003       {
86004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86005       };
86006     } catch (...) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86009       };
86010     }
86011   }
86012   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86013
86014   //argout typemap for const std::string&
86015
86016   return jresult;
86017 }
86018
86019
86020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86021   void * jresult ;
86022   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86023
86024   {
86025     try {
86026       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86027     } catch (std::out_of_range& e) {
86028       {
86029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86030       };
86031     } catch (std::exception& e) {
86032       {
86033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (...) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86038       };
86039     }
86040   }
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86047   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86048
86049   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86050   {
86051     try {
86052       delete arg1;
86053     } catch (std::out_of_range& e) {
86054       {
86055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86056       };
86057     } catch (std::exception& e) {
86058       {
86059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86060       };
86061     } catch (...) {
86062       {
86063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86064       };
86065     }
86066   }
86067 }
86068
86069
86070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86071   void * jresult ;
86072   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86073   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86074
86075   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86076   if (!arg1) {
86077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86078     return 0;
86079   }
86080   {
86081     try {
86082       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86083     } catch (std::out_of_range& e) {
86084       {
86085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86086       };
86087     } catch (std::exception& e) {
86088       {
86089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86094       };
86095     }
86096   }
86097   jresult = (void *)result;
86098   return jresult;
86099 }
86100
86101
86102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86103   void * jresult ;
86104   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86105   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86106   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86107
86108   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86109   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86110   if (!arg2) {
86111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86112     return 0;
86113   }
86114   {
86115     try {
86116       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (...) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86128       };
86129     }
86130   }
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86137   void * jresult ;
86138   Dali::Toolkit::AsyncImageLoader result;
86139
86140   {
86141     try {
86142       result = Dali::Toolkit::AsyncImageLoader::New();
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86150       };
86151     } catch (...) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86154       };
86155     }
86156   }
86157   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86158   return jresult;
86159 }
86160
86161
86162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86163   void * jresult ;
86164   Dali::BaseHandle arg1 ;
86165   Dali::BaseHandle *argp1 ;
86166   Dali::Toolkit::AsyncImageLoader result;
86167
86168   argp1 = (Dali::BaseHandle *)jarg1;
86169   if (!argp1) {
86170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86171     return 0;
86172   }
86173   arg1 = *argp1;
86174   {
86175     try {
86176       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86177     } catch (std::out_of_range& e) {
86178       {
86179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86180       };
86181     } catch (std::exception& e) {
86182       {
86183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86184       };
86185     } catch (...) {
86186       {
86187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86188       };
86189     }
86190   }
86191   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86192   return jresult;
86193 }
86194
86195
86196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86197   unsigned int jresult ;
86198   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86199   std::string *arg2 = 0 ;
86200   uint32_t result;
86201
86202   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86203   if (!jarg2) {
86204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86205     return 0;
86206   }
86207   std::string arg2_str(jarg2);
86208   arg2 = &arg2_str;
86209   {
86210     try {
86211       result = (arg1)->Load((std::string const &)*arg2);
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86219       };
86220     } catch (...) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86223       };
86224     }
86225   }
86226   jresult = result;
86227
86228   //argout typemap for const std::string&
86229
86230   return jresult;
86231 }
86232
86233
86234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86235   unsigned int jresult ;
86236   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86237   std::string *arg2 = 0 ;
86238   Dali::ImageDimensions arg3 ;
86239   Dali::ImageDimensions *argp3 ;
86240   uint32_t result;
86241
86242   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86243   if (!jarg2) {
86244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86245     return 0;
86246   }
86247   std::string arg2_str(jarg2);
86248   arg2 = &arg2_str;
86249   argp3 = (Dali::ImageDimensions *)jarg3;
86250   if (!argp3) {
86251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86252     return 0;
86253   }
86254   arg3 = *argp3;
86255   {
86256     try {
86257       result = (arg1)->Load((std::string const &)*arg2,arg3);
86258     } catch (std::out_of_range& e) {
86259       {
86260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86261       };
86262     } catch (std::exception& e) {
86263       {
86264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (...) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86269       };
86270     }
86271   }
86272   jresult = result;
86273
86274   //argout typemap for const std::string&
86275
86276   return jresult;
86277 }
86278
86279
86280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86281   unsigned int jresult ;
86282   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86283   std::string *arg2 = 0 ;
86284   Dali::ImageDimensions arg3 ;
86285   Dali::FittingMode::Type arg4 ;
86286   Dali::SamplingMode::Type arg5 ;
86287   bool arg6 ;
86288   Dali::ImageDimensions *argp3 ;
86289   uint32_t result;
86290
86291   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86292   if (!jarg2) {
86293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86294     return 0;
86295   }
86296   std::string arg2_str(jarg2);
86297   arg2 = &arg2_str;
86298   argp3 = (Dali::ImageDimensions *)jarg3;
86299   if (!argp3) {
86300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86301     return 0;
86302   }
86303   arg3 = *argp3;
86304   arg4 = (Dali::FittingMode::Type)jarg4;
86305   arg5 = (Dali::SamplingMode::Type)jarg5;
86306   arg6 = jarg6 ? true : false;
86307   {
86308     try {
86309       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86310     } catch (std::out_of_range& e) {
86311       {
86312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86313       };
86314     } catch (std::exception& e) {
86315       {
86316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (...) {
86319       {
86320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86321       };
86322     }
86323   }
86324   jresult = result;
86325
86326   //argout typemap for const std::string&
86327
86328   return jresult;
86329 }
86330
86331
86332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86333   unsigned int jresult ;
86334   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86335   uint32_t arg2 ;
86336   bool result;
86337
86338   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86339   arg2 = (uint32_t)jarg2;
86340   {
86341     try {
86342       result = (bool)(arg1)->Cancel(arg2);
86343     } catch (std::out_of_range& e) {
86344       {
86345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86346       };
86347     } catch (std::exception& e) {
86348       {
86349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86350       };
86351     } catch (...) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86354       };
86355     }
86356   }
86357   jresult = result;
86358   return jresult;
86359 }
86360
86361
86362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86363   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86364
86365   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86366   {
86367     try {
86368       (arg1)->CancelAll();
86369     } catch (std::out_of_range& e) {
86370       {
86371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86372       };
86373     } catch (std::exception& e) {
86374       {
86375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86376       };
86377     } catch (...) {
86378       {
86379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86380       };
86381     }
86382   }
86383 }
86384
86385
86386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86387   void * jresult ;
86388   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86389   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86390
86391   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86392   {
86393     try {
86394       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86395     } catch (std::out_of_range& e) {
86396       {
86397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86398       };
86399     } catch (std::exception& e) {
86400       {
86401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86402       };
86403     } catch (...) {
86404       {
86405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86406       };
86407     }
86408   }
86409   jresult = (void *)result;
86410   return jresult;
86411 }
86412
86413
86414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86415   void * jresult ;
86416   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86417   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86418
86419   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86420   {
86421     try {
86422       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (...) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86434       };
86435     }
86436   }
86437   jresult = (void *)result;
86438   return jresult;
86439 }
86440
86441
86442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86443   void * jresult ;
86444   std::string *arg1 = 0 ;
86445   Dali::PixelData result;
86446
86447   if (!jarg1) {
86448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86449     return 0;
86450   }
86451   std::string arg1_str(jarg1);
86452   arg1 = &arg1_str;
86453   {
86454     try {
86455       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86456     } catch (std::out_of_range& e) {
86457       {
86458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86459       };
86460     } catch (std::exception& e) {
86461       {
86462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86463       };
86464     } catch (...) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86467       };
86468     }
86469   }
86470   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86471
86472   //argout typemap for const std::string&
86473
86474   return jresult;
86475 }
86476
86477
86478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86479   void * jresult ;
86480   std::string *arg1 = 0 ;
86481   Dali::ImageDimensions arg2 ;
86482   Dali::ImageDimensions *argp2 ;
86483   Dali::PixelData result;
86484
86485   if (!jarg1) {
86486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86487     return 0;
86488   }
86489   std::string arg1_str(jarg1);
86490   arg1 = &arg1_str;
86491   argp2 = (Dali::ImageDimensions *)jarg2;
86492   if (!argp2) {
86493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86494     return 0;
86495   }
86496   arg2 = *argp2;
86497   {
86498     try {
86499       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86500     } catch (std::out_of_range& e) {
86501       {
86502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (std::exception& e) {
86505       {
86506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86507       };
86508     } catch (...) {
86509       {
86510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86511       };
86512     }
86513   }
86514   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86515
86516   //argout typemap for const std::string&
86517
86518   return jresult;
86519 }
86520
86521
86522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86523   void * jresult ;
86524   std::string *arg1 = 0 ;
86525   Dali::ImageDimensions arg2 ;
86526   Dali::FittingMode::Type arg3 ;
86527   Dali::SamplingMode::Type arg4 ;
86528   bool arg5 ;
86529   Dali::ImageDimensions *argp2 ;
86530   Dali::PixelData result;
86531
86532   if (!jarg1) {
86533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86534     return 0;
86535   }
86536   std::string arg1_str(jarg1);
86537   arg1 = &arg1_str;
86538   argp2 = (Dali::ImageDimensions *)jarg2;
86539   if (!argp2) {
86540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86541     return 0;
86542   }
86543   arg2 = *argp2;
86544   arg3 = (Dali::FittingMode::Type)jarg3;
86545   arg4 = (Dali::SamplingMode::Type)jarg4;
86546   arg5 = jarg5 ? true : false;
86547   {
86548     try {
86549       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86550     } catch (std::out_of_range& e) {
86551       {
86552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86553       };
86554     } catch (std::exception& e) {
86555       {
86556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86557       };
86558     } catch (...) {
86559       {
86560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86561       };
86562     }
86563   }
86564   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86565
86566   //argout typemap for const std::string&
86567
86568   return jresult;
86569 }
86570
86571
86572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86573   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86574
86575   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86576   {
86577     try {
86578       delete arg1;
86579     } catch (std::out_of_range& e) {
86580       {
86581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86582       };
86583     } catch (std::exception& e) {
86584       {
86585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86586       };
86587     } catch (...) {
86588       {
86589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86590       };
86591     }
86592   }
86593 }
86594
86595
86596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86597   void * jresult ;
86598   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86599   Dali::Actor arg2 ;
86600   Dali::Actor arg3 ;
86601   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86602   Dali::Actor *argp2 ;
86603   Dali::Actor *argp3 ;
86604   Dali::Actor result;
86605
86606   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86607   argp2 = (Dali::Actor *)jarg2;
86608   if (!argp2) {
86609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86610     return 0;
86611   }
86612   arg2 = *argp2;
86613   argp3 = (Dali::Actor *)jarg3;
86614   if (!argp3) {
86615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86616     return 0;
86617   }
86618   arg3 = *argp3;
86619   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86620   {
86621     try {
86622       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86623     } catch (std::out_of_range& e) {
86624       {
86625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86626       };
86627     } catch (std::exception& e) {
86628       {
86629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86630       };
86631     } catch (...) {
86632       {
86633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86634       };
86635     }
86636   }
86637   jresult = new Dali::Actor((const Dali::Actor &)result);
86638   return jresult;
86639 }
86640
86641
86642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86643   void * jresult ;
86644   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86645
86646   {
86647     try {
86648       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86649     } catch (std::out_of_range& e) {
86650       {
86651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86652       };
86653     } catch (std::exception& e) {
86654       {
86655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (...) {
86658       {
86659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86660       };
86661     }
86662   }
86663   jresult = (void *)result;
86664   return jresult;
86665 }
86666
86667
86668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86669   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86670   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86671   if (director) {
86672     director->swig_connect_director(callback0);
86673   }
86674 }
86675
86676
86677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86678   KeyboardFocusManager arg1 ;
86679   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86680   KeyboardFocusManager *argp1 ;
86681
86682   argp1 = (KeyboardFocusManager *)jarg1;
86683   if (!argp1) {
86684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86685     return ;
86686   }
86687   arg1 = *argp1;
86688   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86689   if (!arg2) {
86690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
86691     return ;
86692   }
86693   {
86694     try {
86695       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86696     } catch (std::out_of_range& e) {
86697       {
86698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86699       };
86700     } catch (std::exception& e) {
86701       {
86702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86703       };
86704     } catch (...) {
86705       {
86706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86707       };
86708     }
86709   }
86710 }
86711
86712
86713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86714   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86715
86716   arg1 = (std::vector< unsigned int > *)jarg1;
86717   {
86718     try {
86719       (arg1)->clear();
86720     } catch (std::out_of_range& e) {
86721       {
86722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86723       };
86724     } catch (std::exception& e) {
86725       {
86726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86727       };
86728     } catch (...) {
86729       {
86730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86731       };
86732     }
86733   }
86734 }
86735
86736
86737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86738   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86739   unsigned int *arg2 = 0 ;
86740   unsigned int temp2 ;
86741
86742   arg1 = (std::vector< unsigned int > *)jarg1;
86743   temp2 = (unsigned int)jarg2;
86744   arg2 = &temp2;
86745   {
86746     try {
86747       (arg1)->push_back((unsigned int const &)*arg2);
86748     } catch (std::out_of_range& e) {
86749       {
86750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86751       };
86752     } catch (std::exception& e) {
86753       {
86754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86759       };
86760     }
86761   }
86762 }
86763
86764
86765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86766   unsigned long jresult ;
86767   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86768   std::vector< unsigned int >::size_type result;
86769
86770   arg1 = (std::vector< unsigned int > *)jarg1;
86771   {
86772     try {
86773       result = ((std::vector< unsigned int > const *)arg1)->size();
86774     } catch (std::out_of_range& e) {
86775       {
86776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86777       };
86778     } catch (std::exception& e) {
86779       {
86780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86781       };
86782     } catch (...) {
86783       {
86784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86785       };
86786     }
86787   }
86788   jresult = (unsigned long)result;
86789   return jresult;
86790 }
86791
86792
86793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86794   unsigned long jresult ;
86795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86796   std::vector< unsigned int >::size_type result;
86797
86798   arg1 = (std::vector< unsigned int > *)jarg1;
86799   {
86800     try {
86801       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86802     } catch (std::out_of_range& e) {
86803       {
86804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86805       };
86806     } catch (std::exception& e) {
86807       {
86808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86809       };
86810     } catch (...) {
86811       {
86812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86813       };
86814     }
86815   }
86816   jresult = (unsigned long)result;
86817   return jresult;
86818 }
86819
86820
86821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86822   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86823   std::vector< unsigned int >::size_type arg2 ;
86824
86825   arg1 = (std::vector< unsigned int > *)jarg1;
86826   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86827   {
86828     try {
86829       (arg1)->reserve(arg2);
86830     } catch (std::out_of_range& e) {
86831       {
86832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86833       };
86834     } catch (std::exception& e) {
86835       {
86836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (...) {
86839       {
86840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86841       };
86842     }
86843   }
86844 }
86845
86846
86847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86848   void * jresult ;
86849   std::vector< unsigned int > *result = 0 ;
86850
86851   {
86852     try {
86853       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86854     } catch (std::out_of_range& e) {
86855       {
86856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (std::exception& e) {
86859       {
86860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86865       };
86866     }
86867   }
86868   jresult = (void *)result;
86869   return jresult;
86870 }
86871
86872
86873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86874   void * jresult ;
86875   std::vector< unsigned int > *arg1 = 0 ;
86876   std::vector< unsigned int > *result = 0 ;
86877
86878   arg1 = (std::vector< unsigned int > *)jarg1;
86879   if (!arg1) {
86880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86881     return 0;
86882   }
86883   {
86884     try {
86885       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86886     } catch (std::out_of_range& e) {
86887       {
86888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86889       };
86890     } catch (std::exception& e) {
86891       {
86892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86893       };
86894     } catch (...) {
86895       {
86896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86897       };
86898     }
86899   }
86900   jresult = (void *)result;
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86906   void * jresult ;
86907   int arg1 ;
86908   std::vector< unsigned int > *result = 0 ;
86909
86910   arg1 = (int)jarg1;
86911   {
86912     try {
86913       try {
86914         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86915       }
86916       catch(std::out_of_range &_e) {
86917         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86918         return 0;
86919       }
86920
86921     } catch (std::out_of_range& e) {
86922       {
86923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86924       };
86925     } catch (std::exception& e) {
86926       {
86927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86928       };
86929     } catch (...) {
86930       {
86931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86932       };
86933     }
86934   }
86935   jresult = (void *)result;
86936   return jresult;
86937 }
86938
86939
86940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86941   unsigned int jresult ;
86942   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86943   int arg2 ;
86944   unsigned int result;
86945
86946   arg1 = (std::vector< unsigned int > *)jarg1;
86947   arg2 = (int)jarg2;
86948   {
86949     try {
86950       try {
86951         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86952       }
86953       catch(std::out_of_range &_e) {
86954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86955         return 0;
86956       }
86957
86958     } catch (std::out_of_range& e) {
86959       {
86960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86961       };
86962     } catch (std::exception& e) {
86963       {
86964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86965       };
86966     } catch (...) {
86967       {
86968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86969       };
86970     }
86971   }
86972   jresult = result;
86973   return jresult;
86974 }
86975
86976
86977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86978   unsigned int jresult ;
86979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86980   int arg2 ;
86981   unsigned int *result = 0 ;
86982
86983   arg1 = (std::vector< unsigned int > *)jarg1;
86984   arg2 = (int)jarg2;
86985   {
86986     try {
86987       try {
86988         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86989       }
86990       catch(std::out_of_range &_e) {
86991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86992         return 0;
86993       }
86994
86995     } catch (std::out_of_range& e) {
86996       {
86997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86998       };
86999     } catch (std::exception& e) {
87000       {
87001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87002       };
87003     } catch (...) {
87004       {
87005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87006       };
87007     }
87008   }
87009   jresult = *result;
87010   return jresult;
87011 }
87012
87013
87014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87015   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87016   int arg2 ;
87017   unsigned int *arg3 = 0 ;
87018   unsigned int temp3 ;
87019
87020   arg1 = (std::vector< unsigned int > *)jarg1;
87021   arg2 = (int)jarg2;
87022   temp3 = (unsigned int)jarg3;
87023   arg3 = &temp3;
87024   {
87025     try {
87026       try {
87027         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87028       }
87029       catch(std::out_of_range &_e) {
87030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87031         return ;
87032       }
87033
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (...) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87045       };
87046     }
87047   }
87048 }
87049
87050
87051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87052   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87053   std::vector< unsigned int > *arg2 = 0 ;
87054
87055   arg1 = (std::vector< unsigned int > *)jarg1;
87056   arg2 = (std::vector< unsigned int > *)jarg2;
87057   if (!arg2) {
87058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87059     return ;
87060   }
87061   {
87062     try {
87063       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87064     } catch (std::out_of_range& e) {
87065       {
87066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87067       };
87068     } catch (std::exception& e) {
87069       {
87070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87075       };
87076     }
87077   }
87078 }
87079
87080
87081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87082   void * jresult ;
87083   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87084   int arg2 ;
87085   int arg3 ;
87086   std::vector< unsigned int > *result = 0 ;
87087
87088   arg1 = (std::vector< unsigned int > *)jarg1;
87089   arg2 = (int)jarg2;
87090   arg3 = (int)jarg3;
87091   {
87092     try {
87093       try {
87094         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87095       }
87096       catch(std::out_of_range &_e) {
87097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87098         return 0;
87099       }
87100       catch(std::invalid_argument &_e) {
87101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87102         return 0;
87103       }
87104
87105     } catch (std::out_of_range& e) {
87106       {
87107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87108       };
87109     } catch (std::exception& e) {
87110       {
87111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87112       };
87113     } catch (...) {
87114       {
87115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87116       };
87117     }
87118   }
87119   jresult = (void *)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87125   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87126   int arg2 ;
87127   unsigned int *arg3 = 0 ;
87128   unsigned int temp3 ;
87129
87130   arg1 = (std::vector< unsigned int > *)jarg1;
87131   arg2 = (int)jarg2;
87132   temp3 = (unsigned int)jarg3;
87133   arg3 = &temp3;
87134   {
87135     try {
87136       try {
87137         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87138       }
87139       catch(std::out_of_range &_e) {
87140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87141         return ;
87142       }
87143
87144     } catch (std::out_of_range& e) {
87145       {
87146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87147       };
87148     } catch (std::exception& e) {
87149       {
87150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87151       };
87152     } catch (...) {
87153       {
87154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87155       };
87156     }
87157   }
87158 }
87159
87160
87161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87163   int arg2 ;
87164   std::vector< unsigned int > *arg3 = 0 ;
87165
87166   arg1 = (std::vector< unsigned int > *)jarg1;
87167   arg2 = (int)jarg2;
87168   arg3 = (std::vector< unsigned int > *)jarg3;
87169   if (!arg3) {
87170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87171     return ;
87172   }
87173   {
87174     try {
87175       try {
87176         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87177       }
87178       catch(std::out_of_range &_e) {
87179         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87180         return ;
87181       }
87182
87183     } catch (std::out_of_range& e) {
87184       {
87185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87186       };
87187     } catch (std::exception& e) {
87188       {
87189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87190       };
87191     } catch (...) {
87192       {
87193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87194       };
87195     }
87196   }
87197 }
87198
87199
87200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87201   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87202   int arg2 ;
87203
87204   arg1 = (std::vector< unsigned int > *)jarg1;
87205   arg2 = (int)jarg2;
87206   {
87207     try {
87208       try {
87209         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87210       }
87211       catch(std::out_of_range &_e) {
87212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87213         return ;
87214       }
87215
87216     } catch (std::out_of_range& e) {
87217       {
87218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87219       };
87220     } catch (std::exception& e) {
87221       {
87222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87223       };
87224     } catch (...) {
87225       {
87226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87227       };
87228     }
87229   }
87230 }
87231
87232
87233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87234   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87235   int arg2 ;
87236   int arg3 ;
87237
87238   arg1 = (std::vector< unsigned int > *)jarg1;
87239   arg2 = (int)jarg2;
87240   arg3 = (int)jarg3;
87241   {
87242     try {
87243       try {
87244         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87245       }
87246       catch(std::out_of_range &_e) {
87247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87248         return ;
87249       }
87250       catch(std::invalid_argument &_e) {
87251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87252         return ;
87253       }
87254
87255     } catch (std::out_of_range& e) {
87256       {
87257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87258       };
87259     } catch (std::exception& e) {
87260       {
87261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87262       };
87263     } catch (...) {
87264       {
87265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87266       };
87267     }
87268   }
87269 }
87270
87271
87272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87273   void * jresult ;
87274   unsigned int *arg1 = 0 ;
87275   int arg2 ;
87276   unsigned int temp1 ;
87277   std::vector< unsigned int > *result = 0 ;
87278
87279   temp1 = (unsigned int)jarg1;
87280   arg1 = &temp1;
87281   arg2 = (int)jarg2;
87282   {
87283     try {
87284       try {
87285         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87286       }
87287       catch(std::out_of_range &_e) {
87288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87289         return 0;
87290       }
87291
87292     } catch (std::out_of_range& e) {
87293       {
87294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87295       };
87296     } catch (std::exception& e) {
87297       {
87298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87299       };
87300     } catch (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87303       };
87304     }
87305   }
87306   jresult = (void *)result;
87307   return jresult;
87308 }
87309
87310
87311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87312   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87313
87314   arg1 = (std::vector< unsigned int > *)jarg1;
87315   {
87316     try {
87317       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87318     } catch (std::out_of_range& e) {
87319       {
87320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87321       };
87322     } catch (std::exception& e) {
87323       {
87324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87325       };
87326     } catch (...) {
87327       {
87328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87329       };
87330     }
87331   }
87332 }
87333
87334
87335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87336   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87337   int arg2 ;
87338   int arg3 ;
87339
87340   arg1 = (std::vector< unsigned int > *)jarg1;
87341   arg2 = (int)jarg2;
87342   arg3 = (int)jarg3;
87343   {
87344     try {
87345       try {
87346         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87347       }
87348       catch(std::out_of_range &_e) {
87349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87350         return ;
87351       }
87352       catch(std::invalid_argument &_e) {
87353         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87354         return ;
87355       }
87356
87357     } catch (std::out_of_range& e) {
87358       {
87359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87360       };
87361     } catch (std::exception& e) {
87362       {
87363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87364       };
87365     } catch (...) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87368       };
87369     }
87370   }
87371 }
87372
87373
87374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87375   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87376   int arg2 ;
87377   std::vector< unsigned int > *arg3 = 0 ;
87378
87379   arg1 = (std::vector< unsigned int > *)jarg1;
87380   arg2 = (int)jarg2;
87381   arg3 = (std::vector< unsigned int > *)jarg3;
87382   if (!arg3) {
87383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87384     return ;
87385   }
87386   {
87387     try {
87388       try {
87389         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87390       }
87391       catch(std::out_of_range &_e) {
87392         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87393         return ;
87394       }
87395
87396     } catch (std::out_of_range& e) {
87397       {
87398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87399       };
87400     } catch (std::exception& e) {
87401       {
87402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87407       };
87408     }
87409   }
87410 }
87411
87412
87413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87414   unsigned int jresult ;
87415   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87416   unsigned int *arg2 = 0 ;
87417   unsigned int temp2 ;
87418   bool result;
87419
87420   arg1 = (std::vector< unsigned int > *)jarg1;
87421   temp2 = (unsigned int)jarg2;
87422   arg2 = &temp2;
87423   {
87424     try {
87425       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87426     } catch (std::out_of_range& e) {
87427       {
87428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87429       };
87430     } catch (std::exception& e) {
87431       {
87432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87433       };
87434     } catch (...) {
87435       {
87436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87437       };
87438     }
87439   }
87440   jresult = result;
87441   return jresult;
87442 }
87443
87444
87445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87446   int jresult ;
87447   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87448   unsigned int *arg2 = 0 ;
87449   unsigned int temp2 ;
87450   int result;
87451
87452   arg1 = (std::vector< unsigned int > *)jarg1;
87453   temp2 = (unsigned int)jarg2;
87454   arg2 = &temp2;
87455   {
87456     try {
87457       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87458     } catch (std::out_of_range& e) {
87459       {
87460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87461       };
87462     } catch (std::exception& e) {
87463       {
87464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87465       };
87466     } catch (...) {
87467       {
87468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87469       };
87470     }
87471   }
87472   jresult = result;
87473   return jresult;
87474 }
87475
87476
87477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87478   int jresult ;
87479   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87480   unsigned int *arg2 = 0 ;
87481   unsigned int temp2 ;
87482   int result;
87483
87484   arg1 = (std::vector< unsigned int > *)jarg1;
87485   temp2 = (unsigned int)jarg2;
87486   arg2 = &temp2;
87487   {
87488     try {
87489       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87490     } catch (std::out_of_range& e) {
87491       {
87492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87493       };
87494     } catch (std::exception& e) {
87495       {
87496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87497       };
87498     } catch (...) {
87499       {
87500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87501       };
87502     }
87503   }
87504   jresult = result;
87505   return jresult;
87506 }
87507
87508
87509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87510   unsigned int jresult ;
87511   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87512   unsigned int *arg2 = 0 ;
87513   unsigned int temp2 ;
87514   bool result;
87515
87516   arg1 = (std::vector< unsigned int > *)jarg1;
87517   temp2 = (unsigned int)jarg2;
87518   arg2 = &temp2;
87519   {
87520     try {
87521       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87522     } catch (std::out_of_range& e) {
87523       {
87524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87525       };
87526     } catch (std::exception& e) {
87527       {
87528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87529       };
87530     } catch (...) {
87531       {
87532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87533       };
87534     }
87535   }
87536   jresult = result;
87537   return jresult;
87538 }
87539
87540
87541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87542   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87543
87544   arg1 = (std::vector< unsigned int > *)jarg1;
87545   {
87546     try {
87547       delete arg1;
87548     } catch (std::out_of_range& e) {
87549       {
87550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87551       };
87552     } catch (std::exception& e) {
87553       {
87554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87555       };
87556     } catch (...) {
87557       {
87558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87559       };
87560     }
87561   }
87562 }
87563
87564
87565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87566   void * jresult ;
87567   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87568
87569   {
87570     try {
87571       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87572     } catch (std::out_of_range& e) {
87573       {
87574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87575       };
87576     } catch (std::exception& e) {
87577       {
87578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87579       };
87580     } catch (...) {
87581       {
87582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87583       };
87584     }
87585   }
87586   jresult = (void *)result;
87587   return jresult;
87588 }
87589
87590
87591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87592   void * jresult ;
87593   unsigned int arg1 ;
87594   Dali::Actor arg2 ;
87595   Dali::Actor *argp2 ;
87596   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87597
87598   arg1 = (unsigned int)jarg1;
87599   argp2 = (Dali::Actor *)jarg2;
87600   if (!argp2) {
87601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87602     return 0;
87603   }
87604   arg2 = *argp2;
87605   {
87606     try {
87607       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87608     } catch (std::out_of_range& e) {
87609       {
87610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87611       };
87612     } catch (std::exception& e) {
87613       {
87614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87615       };
87616     } catch (...) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87619       };
87620     }
87621   }
87622   jresult = (void *)result;
87623   return jresult;
87624 }
87625
87626
87627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87628   void * jresult ;
87629   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87630   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87631
87632   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87633   if (!arg1) {
87634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87635     return 0;
87636   }
87637   {
87638     try {
87639       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87640     } catch (std::out_of_range& e) {
87641       {
87642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87643       };
87644     } catch (std::exception& e) {
87645       {
87646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87647       };
87648     } catch (...) {
87649       {
87650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87651       };
87652     }
87653   }
87654   jresult = (void *)result;
87655   return jresult;
87656 }
87657
87658
87659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87660   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87661   unsigned int arg2 ;
87662
87663   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87664   arg2 = (unsigned int)jarg2;
87665   if (arg1) (arg1)->first = arg2;
87666 }
87667
87668
87669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87670   unsigned int jresult ;
87671   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87672   unsigned int result;
87673
87674   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87675   result = (unsigned int) ((arg1)->first);
87676   jresult = result;
87677   return jresult;
87678 }
87679
87680
87681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87682   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87683   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87684
87685   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87686   arg2 = (Dali::Actor *)jarg2;
87687   if (arg1) (arg1)->second = *arg2;
87688 }
87689
87690
87691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87692   void * jresult ;
87693   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87694   Dali::Actor *result = 0 ;
87695
87696   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87697   result = (Dali::Actor *)& ((arg1)->second);
87698   jresult = (void *)result;
87699   return jresult;
87700 }
87701
87702
87703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87704   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87705
87706   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87707   {
87708     try {
87709       delete arg1;
87710     } catch (std::out_of_range& e) {
87711       {
87712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87713       };
87714     } catch (std::exception& e) {
87715       {
87716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87717       };
87718     } catch (...) {
87719       {
87720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87721       };
87722     }
87723   }
87724 }
87725
87726
87727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87728   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87729
87730   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87731   {
87732     try {
87733       (arg1)->clear();
87734     } catch (std::out_of_range& e) {
87735       {
87736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87737       };
87738     } catch (std::exception& e) {
87739       {
87740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87741       };
87742     } catch (...) {
87743       {
87744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87745       };
87746     }
87747   }
87748 }
87749
87750
87751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87752   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87753   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87754
87755   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87756   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87757   if (!arg2) {
87758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87759     return ;
87760   }
87761   {
87762     try {
87763       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87764     } catch (std::out_of_range& e) {
87765       {
87766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87767       };
87768     } catch (std::exception& e) {
87769       {
87770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87771       };
87772     } catch (...) {
87773       {
87774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87775       };
87776     }
87777   }
87778 }
87779
87780
87781 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87782   unsigned long jresult ;
87783   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87784   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87785
87786   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87787   {
87788     try {
87789       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87790     } catch (std::out_of_range& e) {
87791       {
87792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87793       };
87794     } catch (std::exception& e) {
87795       {
87796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87797       };
87798     } catch (...) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87801       };
87802     }
87803   }
87804   jresult = (unsigned long)result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87810   unsigned long jresult ;
87811   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87812   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87813
87814   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87815   {
87816     try {
87817       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87818     } catch (std::out_of_range& e) {
87819       {
87820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87821       };
87822     } catch (std::exception& e) {
87823       {
87824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87825       };
87826     } catch (...) {
87827       {
87828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87829       };
87830     }
87831   }
87832   jresult = (unsigned long)result;
87833   return jresult;
87834 }
87835
87836
87837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87838   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87839   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87840
87841   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87842   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87843   {
87844     try {
87845       (arg1)->reserve(arg2);
87846     } catch (std::out_of_range& e) {
87847       {
87848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87849       };
87850     } catch (std::exception& e) {
87851       {
87852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87853       };
87854     } catch (...) {
87855       {
87856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87857       };
87858     }
87859   }
87860 }
87861
87862
87863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87864   void * jresult ;
87865   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87866
87867   {
87868     try {
87869       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87870     } catch (std::out_of_range& e) {
87871       {
87872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87873       };
87874     } catch (std::exception& e) {
87875       {
87876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87877       };
87878     } catch (...) {
87879       {
87880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87881       };
87882     }
87883   }
87884   jresult = (void *)result;
87885   return jresult;
87886 }
87887
87888
87889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87890   void * jresult ;
87891   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87892   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87893
87894   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87895   if (!arg1) {
87896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87897     return 0;
87898   }
87899   {
87900     try {
87901       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);
87902     } catch (std::out_of_range& e) {
87903       {
87904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87905       };
87906     } catch (std::exception& e) {
87907       {
87908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87909       };
87910     } catch (...) {
87911       {
87912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87913       };
87914     }
87915   }
87916   jresult = (void *)result;
87917   return jresult;
87918 }
87919
87920
87921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87922   void * jresult ;
87923   int arg1 ;
87924   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87925
87926   arg1 = (int)jarg1;
87927   {
87928     try {
87929       try {
87930         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);
87931       }
87932       catch(std::out_of_range &_e) {
87933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87934         return 0;
87935       }
87936
87937     } catch (std::out_of_range& e) {
87938       {
87939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87940       };
87941     } catch (std::exception& e) {
87942       {
87943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87944       };
87945     } catch (...) {
87946       {
87947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87948       };
87949     }
87950   }
87951   jresult = (void *)result;
87952   return jresult;
87953 }
87954
87955
87956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87957   void * jresult ;
87958   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87959   int arg2 ;
87960   std::pair< unsigned int,Dali::Actor > result;
87961
87962   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87963   arg2 = (int)jarg2;
87964   {
87965     try {
87966       try {
87967         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87968       }
87969       catch(std::out_of_range &_e) {
87970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87971         return 0;
87972       }
87973
87974     } catch (std::out_of_range& e) {
87975       {
87976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87977       };
87978     } catch (std::exception& e) {
87979       {
87980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87981       };
87982     } catch (...) {
87983       {
87984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87985       };
87986     }
87987   }
87988   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87989   return jresult;
87990 }
87991
87992
87993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87994   void * jresult ;
87995   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87996   int arg2 ;
87997   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87998
87999   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88000   arg2 = (int)jarg2;
88001   {
88002     try {
88003       try {
88004         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88005       }
88006       catch(std::out_of_range &_e) {
88007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88008         return 0;
88009       }
88010
88011     } catch (std::out_of_range& e) {
88012       {
88013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88014       };
88015     } catch (std::exception& e) {
88016       {
88017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88018       };
88019     } catch (...) {
88020       {
88021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88022       };
88023     }
88024   }
88025   jresult = (void *)result;
88026   return jresult;
88027 }
88028
88029
88030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88031   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88032   int arg2 ;
88033   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88034
88035   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88036   arg2 = (int)jarg2;
88037   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88038   if (!arg3) {
88039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88040     return ;
88041   }
88042   {
88043     try {
88044       try {
88045         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);
88046       }
88047       catch(std::out_of_range &_e) {
88048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88049         return ;
88050       }
88051
88052     } catch (std::out_of_range& e) {
88053       {
88054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88055       };
88056     } catch (std::exception& e) {
88057       {
88058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88059       };
88060     } catch (...) {
88061       {
88062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88063       };
88064     }
88065   }
88066 }
88067
88068
88069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88070   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88072
88073   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88074   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88075   if (!arg2) {
88076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88077     return ;
88078   }
88079   {
88080     try {
88081       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);
88082     } catch (std::out_of_range& e) {
88083       {
88084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88085       };
88086     } catch (std::exception& e) {
88087       {
88088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88089       };
88090     } catch (...) {
88091       {
88092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88093       };
88094     }
88095   }
88096 }
88097
88098
88099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88100   void * jresult ;
88101   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88102   int arg2 ;
88103   int arg3 ;
88104   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88105
88106   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88107   arg2 = (int)jarg2;
88108   arg3 = (int)jarg3;
88109   {
88110     try {
88111       try {
88112         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);
88113       }
88114       catch(std::out_of_range &_e) {
88115         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88116         return 0;
88117       }
88118       catch(std::invalid_argument &_e) {
88119         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88120         return 0;
88121       }
88122
88123     } catch (std::out_of_range& e) {
88124       {
88125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88126       };
88127     } catch (std::exception& e) {
88128       {
88129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88130       };
88131     } catch (...) {
88132       {
88133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88134       };
88135     }
88136   }
88137   jresult = (void *)result;
88138   return jresult;
88139 }
88140
88141
88142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88143   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88144   int arg2 ;
88145   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88146
88147   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88148   arg2 = (int)jarg2;
88149   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88150   if (!arg3) {
88151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88152     return ;
88153   }
88154   {
88155     try {
88156       try {
88157         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);
88158       }
88159       catch(std::out_of_range &_e) {
88160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88161         return ;
88162       }
88163
88164     } catch (std::out_of_range& e) {
88165       {
88166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88167       };
88168     } catch (std::exception& e) {
88169       {
88170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88171       };
88172     } catch (...) {
88173       {
88174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88175       };
88176     }
88177   }
88178 }
88179
88180
88181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88182   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88183   int arg2 ;
88184   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88185
88186   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88187   arg2 = (int)jarg2;
88188   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88189   if (!arg3) {
88190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88191     return ;
88192   }
88193   {
88194     try {
88195       try {
88196         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);
88197       }
88198       catch(std::out_of_range &_e) {
88199         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88200         return ;
88201       }
88202
88203     } catch (std::out_of_range& e) {
88204       {
88205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88206       };
88207     } catch (std::exception& e) {
88208       {
88209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88210       };
88211     } catch (...) {
88212       {
88213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88214       };
88215     }
88216   }
88217 }
88218
88219
88220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88221   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88222   int arg2 ;
88223
88224   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88225   arg2 = (int)jarg2;
88226   {
88227     try {
88228       try {
88229         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88230       }
88231       catch(std::out_of_range &_e) {
88232         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88233         return ;
88234       }
88235
88236     } catch (std::out_of_range& e) {
88237       {
88238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88239       };
88240     } catch (std::exception& e) {
88241       {
88242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88243       };
88244     } catch (...) {
88245       {
88246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88247       };
88248     }
88249   }
88250 }
88251
88252
88253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88254   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88255   int arg2 ;
88256   int arg3 ;
88257
88258   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88259   arg2 = (int)jarg2;
88260   arg3 = (int)jarg3;
88261   {
88262     try {
88263       try {
88264         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88265       }
88266       catch(std::out_of_range &_e) {
88267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88268         return ;
88269       }
88270       catch(std::invalid_argument &_e) {
88271         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88272         return ;
88273       }
88274
88275     } catch (std::out_of_range& e) {
88276       {
88277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88278       };
88279     } catch (std::exception& e) {
88280       {
88281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88282       };
88283     } catch (...) {
88284       {
88285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88286       };
88287     }
88288   }
88289 }
88290
88291
88292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88293   void * jresult ;
88294   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88295   int arg2 ;
88296   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88297
88298   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88299   if (!arg1) {
88300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88301     return 0;
88302   }
88303   arg2 = (int)jarg2;
88304   {
88305     try {
88306       try {
88307         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);
88308       }
88309       catch(std::out_of_range &_e) {
88310         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88311         return 0;
88312       }
88313
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88325       };
88326     }
88327   }
88328   jresult = (void *)result;
88329   return jresult;
88330 }
88331
88332
88333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88334   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88335
88336   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88337   {
88338     try {
88339       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88340     } catch (std::out_of_range& e) {
88341       {
88342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88343       };
88344     } catch (std::exception& e) {
88345       {
88346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88347       };
88348     } catch (...) {
88349       {
88350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88351       };
88352     }
88353   }
88354 }
88355
88356
88357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88358   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88359   int arg2 ;
88360   int arg3 ;
88361
88362   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88363   arg2 = (int)jarg2;
88364   arg3 = (int)jarg3;
88365   {
88366     try {
88367       try {
88368         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88369       }
88370       catch(std::out_of_range &_e) {
88371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88372         return ;
88373       }
88374       catch(std::invalid_argument &_e) {
88375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88376         return ;
88377       }
88378
88379     } catch (std::out_of_range& e) {
88380       {
88381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88382       };
88383     } catch (std::exception& e) {
88384       {
88385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88386       };
88387     } catch (...) {
88388       {
88389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88390       };
88391     }
88392   }
88393 }
88394
88395
88396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88397   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88398   int arg2 ;
88399   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88400
88401   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88402   arg2 = (int)jarg2;
88403   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88404   if (!arg3) {
88405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88406     return ;
88407   }
88408   {
88409     try {
88410       try {
88411         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);
88412       }
88413       catch(std::out_of_range &_e) {
88414         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88415         return ;
88416       }
88417
88418     } catch (std::out_of_range& e) {
88419       {
88420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88421       };
88422     } catch (std::exception& e) {
88423       {
88424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88425       };
88426     } catch (...) {
88427       {
88428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88429       };
88430     }
88431   }
88432 }
88433
88434
88435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88437
88438   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88439   {
88440     try {
88441       delete arg1;
88442     } catch (std::out_of_range& e) {
88443       {
88444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88445       };
88446     } catch (std::exception& e) {
88447       {
88448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88449       };
88450     } catch (...) {
88451       {
88452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88453       };
88454     }
88455   }
88456 }
88457
88458
88459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88460   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88461
88462   arg1 = (std::vector< Dali::Actor > *)jarg1;
88463   {
88464     try {
88465       (arg1)->clear();
88466     } catch (std::out_of_range& e) {
88467       {
88468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88469       };
88470     } catch (std::exception& e) {
88471       {
88472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88473       };
88474     } catch (...) {
88475       {
88476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88477       };
88478     }
88479   }
88480 }
88481
88482
88483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88484   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88485   Dali::Actor *arg2 = 0 ;
88486
88487   arg1 = (std::vector< Dali::Actor > *)jarg1;
88488   arg2 = (Dali::Actor *)jarg2;
88489   if (!arg2) {
88490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88491     return ;
88492   }
88493   {
88494     try {
88495       (arg1)->push_back((Dali::Actor const &)*arg2);
88496     } catch (std::out_of_range& e) {
88497       {
88498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88499       };
88500     } catch (std::exception& e) {
88501       {
88502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88503       };
88504     } catch (...) {
88505       {
88506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88507       };
88508     }
88509   }
88510 }
88511
88512
88513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88514   unsigned long jresult ;
88515   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88516   std::vector< Dali::Actor >::size_type result;
88517
88518   arg1 = (std::vector< Dali::Actor > *)jarg1;
88519   {
88520     try {
88521       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88522     } catch (std::out_of_range& e) {
88523       {
88524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88525       };
88526     } catch (std::exception& e) {
88527       {
88528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88529       };
88530     } catch (...) {
88531       {
88532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88533       };
88534     }
88535   }
88536   jresult = (unsigned long)result;
88537   return jresult;
88538 }
88539
88540
88541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88542   unsigned long jresult ;
88543   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88544   std::vector< Dali::Actor >::size_type result;
88545
88546   arg1 = (std::vector< Dali::Actor > *)jarg1;
88547   {
88548     try {
88549       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88550     } catch (std::out_of_range& e) {
88551       {
88552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88553       };
88554     } catch (std::exception& e) {
88555       {
88556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88557       };
88558     } catch (...) {
88559       {
88560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88561       };
88562     }
88563   }
88564   jresult = (unsigned long)result;
88565   return jresult;
88566 }
88567
88568
88569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88570   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88571   std::vector< Dali::Actor >::size_type arg2 ;
88572
88573   arg1 = (std::vector< Dali::Actor > *)jarg1;
88574   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88575   {
88576     try {
88577       (arg1)->reserve(arg2);
88578     } catch (std::out_of_range& e) {
88579       {
88580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88581       };
88582     } catch (std::exception& e) {
88583       {
88584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88585       };
88586     } catch (...) {
88587       {
88588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88589       };
88590     }
88591   }
88592 }
88593
88594
88595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88596   void * jresult ;
88597   std::vector< Dali::Actor > *result = 0 ;
88598
88599   {
88600     try {
88601       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88602     } catch (std::out_of_range& e) {
88603       {
88604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88605       };
88606     } catch (std::exception& e) {
88607       {
88608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88609       };
88610     } catch (...) {
88611       {
88612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88613       };
88614     }
88615   }
88616   jresult = (void *)result;
88617   return jresult;
88618 }
88619
88620
88621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88622   void * jresult ;
88623   std::vector< Dali::Actor > *arg1 = 0 ;
88624   std::vector< Dali::Actor > *result = 0 ;
88625
88626   arg1 = (std::vector< Dali::Actor > *)jarg1;
88627   if (!arg1) {
88628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88629     return 0;
88630   }
88631   {
88632     try {
88633       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88634     } catch (std::out_of_range& e) {
88635       {
88636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88637       };
88638     } catch (std::exception& e) {
88639       {
88640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88645       };
88646     }
88647   }
88648   jresult = (void *)result;
88649   return jresult;
88650 }
88651
88652
88653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88654   void * jresult ;
88655   int arg1 ;
88656   std::vector< Dali::Actor > *result = 0 ;
88657
88658   arg1 = (int)jarg1;
88659   {
88660     try {
88661       try {
88662         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88663       }
88664       catch(std::out_of_range &_e) {
88665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88666         return 0;
88667       }
88668
88669     } catch (std::out_of_range& e) {
88670       {
88671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88672       };
88673     } catch (std::exception& e) {
88674       {
88675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88680       };
88681     }
88682   }
88683   jresult = (void *)result;
88684   return jresult;
88685 }
88686
88687
88688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88689   void * jresult ;
88690   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88691   int arg2 ;
88692   Dali::Actor result;
88693
88694   arg1 = (std::vector< Dali::Actor > *)jarg1;
88695   arg2 = (int)jarg2;
88696   {
88697     try {
88698       try {
88699         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88700       }
88701       catch(std::out_of_range &_e) {
88702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88703         return 0;
88704       }
88705
88706     } catch (std::out_of_range& e) {
88707       {
88708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88709       };
88710     } catch (std::exception& e) {
88711       {
88712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88713       };
88714     } catch (...) {
88715       {
88716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88717       };
88718     }
88719   }
88720   jresult = new Dali::Actor((const Dali::Actor &)result);
88721   return jresult;
88722 }
88723
88724
88725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88726   void * jresult ;
88727   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88728   int arg2 ;
88729   Dali::Actor *result = 0 ;
88730
88731   arg1 = (std::vector< Dali::Actor > *)jarg1;
88732   arg2 = (int)jarg2;
88733   {
88734     try {
88735       try {
88736         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88737       }
88738       catch(std::out_of_range &_e) {
88739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88740         return 0;
88741       }
88742
88743     } catch (std::out_of_range& e) {
88744       {
88745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88746       };
88747     } catch (std::exception& e) {
88748       {
88749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88750       };
88751     } catch (...) {
88752       {
88753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88754       };
88755     }
88756   }
88757   jresult = (void *)result;
88758   return jresult;
88759 }
88760
88761
88762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88763   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88764   int arg2 ;
88765   Dali::Actor *arg3 = 0 ;
88766
88767   arg1 = (std::vector< Dali::Actor > *)jarg1;
88768   arg2 = (int)jarg2;
88769   arg3 = (Dali::Actor *)jarg3;
88770   if (!arg3) {
88771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88772     return ;
88773   }
88774   {
88775     try {
88776       try {
88777         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88778       }
88779       catch(std::out_of_range &_e) {
88780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88781         return ;
88782       }
88783
88784     } catch (std::out_of_range& e) {
88785       {
88786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88787       };
88788     } catch (std::exception& e) {
88789       {
88790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88791       };
88792     } catch (...) {
88793       {
88794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88795       };
88796     }
88797   }
88798 }
88799
88800
88801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88802   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88803   std::vector< Dali::Actor > *arg2 = 0 ;
88804
88805   arg1 = (std::vector< Dali::Actor > *)jarg1;
88806   arg2 = (std::vector< Dali::Actor > *)jarg2;
88807   if (!arg2) {
88808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88809     return ;
88810   }
88811   {
88812     try {
88813       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88814     } catch (std::out_of_range& e) {
88815       {
88816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88817       };
88818     } catch (std::exception& e) {
88819       {
88820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88821       };
88822     } catch (...) {
88823       {
88824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88825       };
88826     }
88827   }
88828 }
88829
88830
88831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88832   void * jresult ;
88833   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88834   int arg2 ;
88835   int arg3 ;
88836   std::vector< Dali::Actor > *result = 0 ;
88837
88838   arg1 = (std::vector< Dali::Actor > *)jarg1;
88839   arg2 = (int)jarg2;
88840   arg3 = (int)jarg3;
88841   {
88842     try {
88843       try {
88844         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88845       }
88846       catch(std::out_of_range &_e) {
88847         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88848         return 0;
88849       }
88850       catch(std::invalid_argument &_e) {
88851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88852         return 0;
88853       }
88854
88855     } catch (std::out_of_range& e) {
88856       {
88857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88858       };
88859     } catch (std::exception& e) {
88860       {
88861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88862       };
88863     } catch (...) {
88864       {
88865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88866       };
88867     }
88868   }
88869   jresult = (void *)result;
88870   return jresult;
88871 }
88872
88873
88874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88875   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88876   int arg2 ;
88877   Dali::Actor *arg3 = 0 ;
88878
88879   arg1 = (std::vector< Dali::Actor > *)jarg1;
88880   arg2 = (int)jarg2;
88881   arg3 = (Dali::Actor *)jarg3;
88882   if (!arg3) {
88883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88884     return ;
88885   }
88886   {
88887     try {
88888       try {
88889         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88890       }
88891       catch(std::out_of_range &_e) {
88892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88893         return ;
88894       }
88895
88896     } catch (std::out_of_range& e) {
88897       {
88898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88899       };
88900     } catch (std::exception& e) {
88901       {
88902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88903       };
88904     } catch (...) {
88905       {
88906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88907       };
88908     }
88909   }
88910 }
88911
88912
88913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88914   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88915   int arg2 ;
88916   std::vector< Dali::Actor > *arg3 = 0 ;
88917
88918   arg1 = (std::vector< Dali::Actor > *)jarg1;
88919   arg2 = (int)jarg2;
88920   arg3 = (std::vector< Dali::Actor > *)jarg3;
88921   if (!arg3) {
88922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88923     return ;
88924   }
88925   {
88926     try {
88927       try {
88928         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88929       }
88930       catch(std::out_of_range &_e) {
88931         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88932         return ;
88933       }
88934
88935     } catch (std::out_of_range& e) {
88936       {
88937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88938       };
88939     } catch (std::exception& e) {
88940       {
88941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88942       };
88943     } catch (...) {
88944       {
88945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88946       };
88947     }
88948   }
88949 }
88950
88951
88952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88953   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88954   int arg2 ;
88955
88956   arg1 = (std::vector< Dali::Actor > *)jarg1;
88957   arg2 = (int)jarg2;
88958   {
88959     try {
88960       try {
88961         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88962       }
88963       catch(std::out_of_range &_e) {
88964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88965         return ;
88966       }
88967
88968     } catch (std::out_of_range& e) {
88969       {
88970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88971       };
88972     } catch (std::exception& e) {
88973       {
88974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88975       };
88976     } catch (...) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88979       };
88980     }
88981   }
88982 }
88983
88984
88985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88986   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88987   int arg2 ;
88988   int arg3 ;
88989
88990   arg1 = (std::vector< Dali::Actor > *)jarg1;
88991   arg2 = (int)jarg2;
88992   arg3 = (int)jarg3;
88993   {
88994     try {
88995       try {
88996         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88997       }
88998       catch(std::out_of_range &_e) {
88999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89000         return ;
89001       }
89002       catch(std::invalid_argument &_e) {
89003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89004         return ;
89005       }
89006
89007     } catch (std::out_of_range& e) {
89008       {
89009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89010       };
89011     } catch (std::exception& e) {
89012       {
89013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89014       };
89015     } catch (...) {
89016       {
89017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89018       };
89019     }
89020   }
89021 }
89022
89023
89024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89025   void * jresult ;
89026   Dali::Actor *arg1 = 0 ;
89027   int arg2 ;
89028   std::vector< Dali::Actor > *result = 0 ;
89029
89030   arg1 = (Dali::Actor *)jarg1;
89031   if (!arg1) {
89032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89033     return 0;
89034   }
89035   arg2 = (int)jarg2;
89036   {
89037     try {
89038       try {
89039         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89040       }
89041       catch(std::out_of_range &_e) {
89042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89043         return 0;
89044       }
89045
89046     } catch (std::out_of_range& e) {
89047       {
89048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89049       };
89050     } catch (std::exception& e) {
89051       {
89052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89053       };
89054     } catch (...) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89057       };
89058     }
89059   }
89060   jresult = (void *)result;
89061   return jresult;
89062 }
89063
89064
89065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89066   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89067
89068   arg1 = (std::vector< Dali::Actor > *)jarg1;
89069   {
89070     try {
89071       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89072     } catch (std::out_of_range& e) {
89073       {
89074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89075       };
89076     } catch (std::exception& e) {
89077       {
89078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89079       };
89080     } catch (...) {
89081       {
89082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89083       };
89084     }
89085   }
89086 }
89087
89088
89089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89090   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89091   int arg2 ;
89092   int arg3 ;
89093
89094   arg1 = (std::vector< Dali::Actor > *)jarg1;
89095   arg2 = (int)jarg2;
89096   arg3 = (int)jarg3;
89097   {
89098     try {
89099       try {
89100         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89101       }
89102       catch(std::out_of_range &_e) {
89103         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89104         return ;
89105       }
89106       catch(std::invalid_argument &_e) {
89107         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89108         return ;
89109       }
89110
89111     } catch (std::out_of_range& e) {
89112       {
89113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89114       };
89115     } catch (std::exception& e) {
89116       {
89117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89118       };
89119     } catch (...) {
89120       {
89121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89122       };
89123     }
89124   }
89125 }
89126
89127
89128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89129   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89130   int arg2 ;
89131   std::vector< Dali::Actor > *arg3 = 0 ;
89132
89133   arg1 = (std::vector< Dali::Actor > *)jarg1;
89134   arg2 = (int)jarg2;
89135   arg3 = (std::vector< Dali::Actor > *)jarg3;
89136   if (!arg3) {
89137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89138     return ;
89139   }
89140   {
89141     try {
89142       try {
89143         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89144       }
89145       catch(std::out_of_range &_e) {
89146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89147         return ;
89148       }
89149
89150     } catch (std::out_of_range& e) {
89151       {
89152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89153       };
89154     } catch (std::exception& e) {
89155       {
89156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89157       };
89158     } catch (...) {
89159       {
89160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89161       };
89162     }
89163   }
89164 }
89165
89166
89167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89168   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89169
89170   arg1 = (std::vector< Dali::Actor > *)jarg1;
89171   {
89172     try {
89173       delete arg1;
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89181       };
89182     } catch (...) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89185       };
89186     }
89187   }
89188 }
89189
89190
89191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89192   unsigned int jresult ;
89193   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89194   bool result;
89195
89196   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89197   {
89198     try {
89199       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89200     } catch (std::out_of_range& e) {
89201       {
89202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89203       };
89204     } catch (std::exception& e) {
89205       {
89206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89207       };
89208     } catch (...) {
89209       {
89210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89211       };
89212     }
89213   }
89214   jresult = result;
89215   return jresult;
89216 }
89217
89218
89219 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89220   unsigned long jresult ;
89221   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89222   std::size_t result;
89223
89224   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89225   {
89226     try {
89227       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89228     } catch (std::out_of_range& e) {
89229       {
89230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89231       };
89232     } catch (std::exception& e) {
89233       {
89234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89239       };
89240     }
89241   }
89242   jresult = (unsigned long)result;
89243   return jresult;
89244 }
89245
89246
89247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89248   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89249   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89250
89251   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89252   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89253   {
89254     try {
89255       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89256     } catch (std::out_of_range& e) {
89257       {
89258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89259       };
89260     } catch (std::exception& e) {
89261       {
89262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89263       };
89264     } catch (...) {
89265       {
89266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89267       };
89268     }
89269   }
89270 }
89271
89272
89273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89274   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89275   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89276
89277   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89278   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89279   {
89280     try {
89281       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89282     } catch (std::out_of_range& e) {
89283       {
89284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89285       };
89286     } catch (std::exception& e) {
89287       {
89288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89289       };
89290     } catch (...) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89293       };
89294     }
89295   }
89296 }
89297
89298
89299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89300   unsigned int jresult ;
89301   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89302   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89303   bool result;
89304
89305   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89306   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89307   if (!arg2) {
89308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89309     return 0;
89310   }
89311   {
89312     try {
89313       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89314     } catch (std::out_of_range& e) {
89315       {
89316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (std::exception& e) {
89319       {
89320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328   jresult = result;
89329   return jresult;
89330 }
89331
89332
89333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89334   void * jresult ;
89335   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89336
89337   {
89338     try {
89339       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89340     } catch (std::out_of_range& e) {
89341       {
89342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89343       };
89344     } catch (std::exception& e) {
89345       {
89346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89347       };
89348     } catch (...) {
89349       {
89350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89351       };
89352     }
89353   }
89354   jresult = (void *)result;
89355   return jresult;
89356 }
89357
89358
89359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89360   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89361
89362   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89363   {
89364     try {
89365       delete arg1;
89366     } catch (std::out_of_range& e) {
89367       {
89368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89369       };
89370     } catch (std::exception& e) {
89371       {
89372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (...) {
89375       {
89376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89377       };
89378     }
89379   }
89380 }
89381
89382
89383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89384   unsigned int jresult ;
89385   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89386   bool result;
89387
89388   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89389   {
89390     try {
89391       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);
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (...) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89403       };
89404     }
89405   }
89406   jresult = result;
89407   return jresult;
89408 }
89409
89410
89411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89412   unsigned long jresult ;
89413   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89414   std::size_t result;
89415
89416   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89417   {
89418     try {
89419       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);
89420     } catch (std::out_of_range& e) {
89421       {
89422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89423       };
89424     } catch (std::exception& e) {
89425       {
89426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89427       };
89428     } catch (...) {
89429       {
89430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89431       };
89432     }
89433   }
89434   jresult = (unsigned long)result;
89435   return jresult;
89436 }
89437
89438
89439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89440   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89441   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89442
89443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89444   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89445   {
89446     try {
89447       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89455       };
89456     } catch (...) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89459       };
89460     }
89461   }
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89466   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89467   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89468
89469   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89470   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89471   {
89472     try {
89473       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89474     } catch (std::out_of_range& e) {
89475       {
89476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89477       };
89478     } catch (std::exception& e) {
89479       {
89480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89481       };
89482     } catch (...) {
89483       {
89484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89485       };
89486     }
89487   }
89488 }
89489
89490
89491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89492   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89493   Dali::Actor arg2 ;
89494   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89495   Dali::Actor *argp2 ;
89496
89497   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89498   argp2 = (Dali::Actor *)jarg2;
89499   if (!argp2) {
89500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89501     return ;
89502   }
89503   arg2 = *argp2;
89504   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89505   {
89506     try {
89507       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89515       };
89516     } catch (...) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89519       };
89520     }
89521   }
89522 }
89523
89524
89525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89526   void * jresult ;
89527   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89528
89529   {
89530     try {
89531       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89543       };
89544     }
89545   }
89546   jresult = (void *)result;
89547   return jresult;
89548 }
89549
89550
89551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89552   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89553
89554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89555   {
89556     try {
89557       delete arg1;
89558     } catch (std::out_of_range& e) {
89559       {
89560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89561       };
89562     } catch (std::exception& e) {
89563       {
89564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89565       };
89566     } catch (...) {
89567       {
89568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89569       };
89570     }
89571   }
89572 }
89573
89574
89575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89576   unsigned int jresult ;
89577   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89578   bool result;
89579
89580   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89581   {
89582     try {
89583       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89584     } catch (std::out_of_range& e) {
89585       {
89586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89587       };
89588     } catch (std::exception& e) {
89589       {
89590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89591       };
89592     } catch (...) {
89593       {
89594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89595       };
89596     }
89597   }
89598   jresult = result;
89599   return jresult;
89600 }
89601
89602
89603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89604   unsigned long jresult ;
89605   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89606   std::size_t result;
89607
89608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89609   {
89610     try {
89611       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89612     } catch (std::out_of_range& e) {
89613       {
89614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89615       };
89616     } catch (std::exception& e) {
89617       {
89618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89619       };
89620     } catch (...) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89623       };
89624     }
89625   }
89626   jresult = (unsigned long)result;
89627   return jresult;
89628 }
89629
89630
89631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89632   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89633   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89634
89635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89636   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89637   {
89638     try {
89639       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89640     } catch (std::out_of_range& e) {
89641       {
89642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89643       };
89644     } catch (std::exception& e) {
89645       {
89646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89647       };
89648     } catch (...) {
89649       {
89650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89651       };
89652     }
89653   }
89654 }
89655
89656
89657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89658   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89659   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89660
89661   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89662   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89663   {
89664     try {
89665       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89666     } catch (std::out_of_range& e) {
89667       {
89668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89669       };
89670     } catch (std::exception& e) {
89671       {
89672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89673       };
89674     } catch (...) {
89675       {
89676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89677       };
89678     }
89679   }
89680 }
89681
89682
89683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89684   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89685   Dali::Actor arg2 ;
89686   Dali::Actor arg3 ;
89687   Dali::Actor *argp2 ;
89688   Dali::Actor *argp3 ;
89689
89690   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89691   argp2 = (Dali::Actor *)jarg2;
89692   if (!argp2) {
89693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89694     return ;
89695   }
89696   arg2 = *argp2;
89697   argp3 = (Dali::Actor *)jarg3;
89698   if (!argp3) {
89699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89700     return ;
89701   }
89702   arg3 = *argp3;
89703   {
89704     try {
89705       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89706     } catch (std::out_of_range& e) {
89707       {
89708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (std::exception& e) {
89711       {
89712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89713       };
89714     } catch (...) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89717       };
89718     }
89719   }
89720 }
89721
89722
89723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89724   void * jresult ;
89725   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89726
89727   {
89728     try {
89729       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89730     } catch (std::out_of_range& e) {
89731       {
89732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89733       };
89734     } catch (std::exception& e) {
89735       {
89736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (...) {
89739       {
89740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89741       };
89742     }
89743   }
89744   jresult = (void *)result;
89745   return jresult;
89746 }
89747
89748
89749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89750   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89751
89752   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89753   {
89754     try {
89755       delete arg1;
89756     } catch (std::out_of_range& e) {
89757       {
89758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89759       };
89760     } catch (std::exception& e) {
89761       {
89762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89763       };
89764     } catch (...) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89767       };
89768     }
89769   }
89770 }
89771
89772
89773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89774   unsigned int jresult ;
89775   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89776   bool result;
89777
89778   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89779   {
89780     try {
89781       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89782     } catch (std::out_of_range& e) {
89783       {
89784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89785       };
89786     } catch (std::exception& e) {
89787       {
89788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89789       };
89790     } catch (...) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89793       };
89794     }
89795   }
89796   jresult = result;
89797   return jresult;
89798 }
89799
89800
89801 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89802   unsigned long jresult ;
89803   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89804   std::size_t result;
89805
89806   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89807   {
89808     try {
89809       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89817       };
89818     } catch (...) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89821       };
89822     }
89823   }
89824   jresult = (unsigned long)result;
89825   return jresult;
89826 }
89827
89828
89829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89830   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89831   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89832
89833   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89834   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89835   {
89836     try {
89837       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89845       };
89846     } catch (...) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89849       };
89850     }
89851   }
89852 }
89853
89854
89855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89856   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89857   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89858
89859   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89860   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89861   {
89862     try {
89863       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89871       };
89872     } catch (...) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89875       };
89876     }
89877   }
89878 }
89879
89880
89881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89882   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89883   Dali::Actor arg2 ;
89884   bool arg3 ;
89885   Dali::Actor *argp2 ;
89886
89887   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89888   argp2 = (Dali::Actor *)jarg2;
89889   if (!argp2) {
89890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89891     return ;
89892   }
89893   arg2 = *argp2;
89894   arg3 = jarg3 ? true : false;
89895   {
89896     try {
89897       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89898     } catch (std::out_of_range& e) {
89899       {
89900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89901       };
89902     } catch (std::exception& e) {
89903       {
89904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89905       };
89906     } catch (...) {
89907       {
89908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89909       };
89910     }
89911   }
89912 }
89913
89914
89915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89916   void * jresult ;
89917   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89918
89919   {
89920     try {
89921       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89922     } catch (std::out_of_range& e) {
89923       {
89924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89925       };
89926     } catch (std::exception& e) {
89927       {
89928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89929       };
89930     } catch (...) {
89931       {
89932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89933       };
89934     }
89935   }
89936   jresult = (void *)result;
89937   return jresult;
89938 }
89939
89940
89941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89942   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89943
89944   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89945   {
89946     try {
89947       delete arg1;
89948     } catch (std::out_of_range& e) {
89949       {
89950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89951       };
89952     } catch (std::exception& e) {
89953       {
89954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89955       };
89956     } catch (...) {
89957       {
89958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89959       };
89960     }
89961   }
89962 }
89963
89964
89965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89966   unsigned int jresult ;
89967   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89968   bool result;
89969
89970   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89971   {
89972     try {
89973       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);
89974     } catch (std::out_of_range& e) {
89975       {
89976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89977       };
89978     } catch (std::exception& e) {
89979       {
89980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (...) {
89983       {
89984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89985       };
89986     }
89987   }
89988   jresult = result;
89989   return jresult;
89990 }
89991
89992
89993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89994   unsigned long jresult ;
89995   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89996   std::size_t result;
89997
89998   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89999   {
90000     try {
90001       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);
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90009       };
90010     } catch (...) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90013       };
90014     }
90015   }
90016   jresult = (unsigned long)result;
90017   return jresult;
90018 }
90019
90020
90021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90022   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90023   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90024
90025   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90026   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90027   {
90028     try {
90029       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90030     } catch (std::out_of_range& e) {
90031       {
90032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90033       };
90034     } catch (std::exception& e) {
90035       {
90036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90041       };
90042     }
90043   }
90044 }
90045
90046
90047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90048   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90049   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90050
90051   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90052   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90053   {
90054     try {
90055       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90056     } catch (std::out_of_range& e) {
90057       {
90058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90059       };
90060     } catch (std::exception& e) {
90061       {
90062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90063       };
90064     } catch (...) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90067       };
90068     }
90069   }
90070 }
90071
90072
90073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90074   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90075   Dali::Toolkit::StyleManager arg2 ;
90076   Dali::StyleChange::Type arg3 ;
90077   Dali::Toolkit::StyleManager *argp2 ;
90078
90079   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90080   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90081   if (!argp2) {
90082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90083     return ;
90084   }
90085   arg2 = *argp2;
90086   arg3 = (Dali::StyleChange::Type)jarg3;
90087   {
90088     try {
90089       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90090     } catch (std::out_of_range& e) {
90091       {
90092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90093       };
90094     } catch (std::exception& e) {
90095       {
90096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90097       };
90098     } catch (...) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90101       };
90102     }
90103   }
90104 }
90105
90106
90107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90108   void * jresult ;
90109   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90110
90111   {
90112     try {
90113       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90114     } catch (std::out_of_range& e) {
90115       {
90116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (std::exception& e) {
90119       {
90120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90121       };
90122     } catch (...) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90125       };
90126     }
90127   }
90128   jresult = (void *)result;
90129   return jresult;
90130 }
90131
90132
90133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90134   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90135
90136   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90137   {
90138     try {
90139       delete arg1;
90140     } catch (std::out_of_range& e) {
90141       {
90142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90143       };
90144     } catch (std::exception& e) {
90145       {
90146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90151       };
90152     }
90153   }
90154 }
90155
90156
90157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90158   unsigned int jresult ;
90159   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90160   bool result;
90161
90162   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90163   {
90164     try {
90165       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90166     } catch (std::out_of_range& e) {
90167       {
90168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90169       };
90170     } catch (std::exception& e) {
90171       {
90172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90173       };
90174     } catch (...) {
90175       {
90176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90177       };
90178     }
90179   }
90180   jresult = result;
90181   return jresult;
90182 }
90183
90184
90185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90186   unsigned long jresult ;
90187   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90188   std::size_t result;
90189
90190   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90191   {
90192     try {
90193       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90194     } catch (std::out_of_range& e) {
90195       {
90196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90197       };
90198     } catch (std::exception& e) {
90199       {
90200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90201       };
90202     } catch (...) {
90203       {
90204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90205       };
90206     }
90207   }
90208   jresult = (unsigned long)result;
90209   return jresult;
90210 }
90211
90212
90213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90214   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90215   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90216
90217   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90218   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90219   {
90220     try {
90221       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90222     } catch (std::out_of_range& e) {
90223       {
90224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90225       };
90226     } catch (std::exception& e) {
90227       {
90228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90229       };
90230     } catch (...) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90233       };
90234     }
90235   }
90236 }
90237
90238
90239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90240   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90241   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90242
90243   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90244   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90245   {
90246     try {
90247       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90248     } catch (std::out_of_range& e) {
90249       {
90250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90251       };
90252     } catch (std::exception& e) {
90253       {
90254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90255       };
90256     } catch (...) {
90257       {
90258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90259       };
90260     }
90261   }
90262 }
90263
90264
90265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90266   unsigned int jresult ;
90267   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90268   Dali::Toolkit::Button arg2 ;
90269   Dali::Toolkit::Button *argp2 ;
90270   bool result;
90271
90272   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90273   argp2 = (Dali::Toolkit::Button *)jarg2;
90274   if (!argp2) {
90275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90276     return 0;
90277   }
90278   arg2 = *argp2;
90279   {
90280     try {
90281       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90282     } catch (std::out_of_range& e) {
90283       {
90284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (std::exception& e) {
90287       {
90288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90293       };
90294     }
90295   }
90296   jresult = result;
90297   return jresult;
90298 }
90299
90300
90301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90302   void * jresult ;
90303   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90304
90305   {
90306     try {
90307       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90308     } catch (std::out_of_range& e) {
90309       {
90310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90311       };
90312     } catch (std::exception& e) {
90313       {
90314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90315       };
90316     } catch (...) {
90317       {
90318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90319       };
90320     }
90321   }
90322   jresult = (void *)result;
90323   return jresult;
90324 }
90325
90326
90327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90328   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90329
90330   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90331   {
90332     try {
90333       delete arg1;
90334     } catch (std::out_of_range& e) {
90335       {
90336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90337       };
90338     } catch (std::exception& e) {
90339       {
90340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90345       };
90346     }
90347   }
90348 }
90349
90350
90351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90352   unsigned int jresult ;
90353   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90354   bool result;
90355
90356   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90357   {
90358     try {
90359       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90360     } catch (std::out_of_range& e) {
90361       {
90362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90363       };
90364     } catch (std::exception& e) {
90365       {
90366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90367       };
90368     } catch (...) {
90369       {
90370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90371       };
90372     }
90373   }
90374   jresult = result;
90375   return jresult;
90376 }
90377
90378
90379 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90380   unsigned long jresult ;
90381   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90382   std::size_t result;
90383
90384   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90385   {
90386     try {
90387       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90388     } catch (std::out_of_range& e) {
90389       {
90390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90391       };
90392     } catch (std::exception& e) {
90393       {
90394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90395       };
90396     } catch (...) {
90397       {
90398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90399       };
90400     }
90401   }
90402   jresult = (unsigned long)result;
90403   return jresult;
90404 }
90405
90406
90407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90408   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90409   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90410
90411   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90412   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90413   {
90414     try {
90415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90423       };
90424     } catch (...) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90427       };
90428     }
90429   }
90430 }
90431
90432
90433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90434   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90435   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90436
90437   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90438   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90439   {
90440     try {
90441       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90442     } catch (std::out_of_range& e) {
90443       {
90444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90445       };
90446     } catch (std::exception& e) {
90447       {
90448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90449       };
90450     } catch (...) {
90451       {
90452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90453       };
90454     }
90455   }
90456 }
90457
90458
90459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90460   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90461   Dali::Toolkit::GaussianBlurView arg2 ;
90462   Dali::Toolkit::GaussianBlurView *argp2 ;
90463
90464   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90465   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90466   if (!argp2) {
90467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90468     return ;
90469   }
90470   arg2 = *argp2;
90471   {
90472     try {
90473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90474     } catch (std::out_of_range& e) {
90475       {
90476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90477       };
90478     } catch (std::exception& e) {
90479       {
90480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90481       };
90482     } catch (...) {
90483       {
90484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90485       };
90486     }
90487   }
90488 }
90489
90490
90491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90492   void * jresult ;
90493   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90494
90495   {
90496     try {
90497       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90498     } catch (std::out_of_range& e) {
90499       {
90500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90501       };
90502     } catch (std::exception& e) {
90503       {
90504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90509       };
90510     }
90511   }
90512   jresult = (void *)result;
90513   return jresult;
90514 }
90515
90516
90517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90518   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90519
90520   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90521   {
90522     try {
90523       delete arg1;
90524     } catch (std::out_of_range& e) {
90525       {
90526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90527       };
90528     } catch (std::exception& e) {
90529       {
90530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90531       };
90532     } catch (...) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90535       };
90536     }
90537   }
90538 }
90539
90540
90541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90542   unsigned int jresult ;
90543   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90544   bool result;
90545
90546   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90547   {
90548     try {
90549       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);
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90557       };
90558     } catch (...) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90561       };
90562     }
90563   }
90564   jresult = result;
90565   return jresult;
90566 }
90567
90568
90569 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90570   unsigned long jresult ;
90571   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90572   std::size_t result;
90573
90574   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90575   {
90576     try {
90577       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);
90578     } catch (std::out_of_range& e) {
90579       {
90580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90581       };
90582     } catch (std::exception& e) {
90583       {
90584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90585       };
90586     } catch (...) {
90587       {
90588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90589       };
90590     }
90591   }
90592   jresult = (unsigned long)result;
90593   return jresult;
90594 }
90595
90596
90597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90598   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90599   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90600
90601   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90602   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90603   {
90604     try {
90605       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90606     } catch (std::out_of_range& e) {
90607       {
90608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90609       };
90610     } catch (std::exception& e) {
90611       {
90612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90613       };
90614     } catch (...) {
90615       {
90616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90617       };
90618     }
90619   }
90620 }
90621
90622
90623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90624   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90625   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90626
90627   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90628   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90629   {
90630     try {
90631       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90632     } catch (std::out_of_range& e) {
90633       {
90634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90635       };
90636     } catch (std::exception& e) {
90637       {
90638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90639       };
90640     } catch (...) {
90641       {
90642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90643       };
90644     }
90645   }
90646 }
90647
90648
90649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90650   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90651   Dali::Toolkit::PageTurnView arg2 ;
90652   unsigned int arg3 ;
90653   bool arg4 ;
90654   Dali::Toolkit::PageTurnView *argp2 ;
90655
90656   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90657   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90658   if (!argp2) {
90659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90660     return ;
90661   }
90662   arg2 = *argp2;
90663   arg3 = (unsigned int)jarg3;
90664   arg4 = jarg4 ? true : false;
90665   {
90666     try {
90667       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90668     } catch (std::out_of_range& e) {
90669       {
90670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90671       };
90672     } catch (std::exception& e) {
90673       {
90674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90675       };
90676     } catch (...) {
90677       {
90678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90679       };
90680     }
90681   }
90682 }
90683
90684
90685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90686   void * jresult ;
90687   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90688
90689   {
90690     try {
90691       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90692     } catch (std::out_of_range& e) {
90693       {
90694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90695       };
90696     } catch (std::exception& e) {
90697       {
90698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90699       };
90700     } catch (...) {
90701       {
90702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90703       };
90704     }
90705   }
90706   jresult = (void *)result;
90707   return jresult;
90708 }
90709
90710
90711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90712   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90713
90714   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90715   {
90716     try {
90717       delete arg1;
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90725       };
90726     } catch (...) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90729       };
90730     }
90731   }
90732 }
90733
90734
90735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90736   unsigned int jresult ;
90737   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90738   bool result;
90739
90740   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90741   {
90742     try {
90743       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90744     } catch (std::out_of_range& e) {
90745       {
90746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90747       };
90748     } catch (std::exception& e) {
90749       {
90750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90751       };
90752     } catch (...) {
90753       {
90754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90755       };
90756     }
90757   }
90758   jresult = result;
90759   return jresult;
90760 }
90761
90762
90763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90764   unsigned long jresult ;
90765   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90766   std::size_t result;
90767
90768   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90769   {
90770     try {
90771       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90772     } catch (std::out_of_range& e) {
90773       {
90774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90775       };
90776     } catch (std::exception& e) {
90777       {
90778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90779       };
90780     } catch (...) {
90781       {
90782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90783       };
90784     }
90785   }
90786   jresult = (unsigned long)result;
90787   return jresult;
90788 }
90789
90790
90791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90792   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90793   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90794
90795   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90796   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90797   {
90798     try {
90799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90800     } catch (std::out_of_range& e) {
90801       {
90802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90803       };
90804     } catch (std::exception& e) {
90805       {
90806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90807       };
90808     } catch (...) {
90809       {
90810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90811       };
90812     }
90813   }
90814 }
90815
90816
90817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90818   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90819   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90820
90821   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90822   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90823   {
90824     try {
90825       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90826     } catch (std::out_of_range& e) {
90827       {
90828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90829       };
90830     } catch (std::exception& e) {
90831       {
90832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90833       };
90834     } catch (...) {
90835       {
90836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90837       };
90838     }
90839   }
90840 }
90841
90842
90843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90844   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90845   Dali::Toolkit::PageTurnView arg2 ;
90846   Dali::Toolkit::PageTurnView *argp2 ;
90847
90848   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90849   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90850   if (!argp2) {
90851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90852     return ;
90853   }
90854   arg2 = *argp2;
90855   {
90856     try {
90857       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90858     } catch (std::out_of_range& e) {
90859       {
90860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90861       };
90862     } catch (std::exception& e) {
90863       {
90864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90865       };
90866     } catch (...) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90869       };
90870     }
90871   }
90872 }
90873
90874
90875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90876   void * jresult ;
90877   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90878
90879   {
90880     try {
90881       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90882     } catch (std::out_of_range& e) {
90883       {
90884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90885       };
90886     } catch (std::exception& e) {
90887       {
90888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (...) {
90891       {
90892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90893       };
90894     }
90895   }
90896   jresult = (void *)result;
90897   return jresult;
90898 }
90899
90900
90901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90902   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90903
90904   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90905   {
90906     try {
90907       delete arg1;
90908     } catch (std::out_of_range& e) {
90909       {
90910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90911       };
90912     } catch (std::exception& e) {
90913       {
90914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90915       };
90916     } catch (...) {
90917       {
90918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90919       };
90920     }
90921   }
90922 }
90923
90924
90925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
90926   unsigned int jresult ;
90927   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90928   bool result;
90929
90930   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90931   {
90932     try {
90933       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);
90934     } catch (std::out_of_range& e) {
90935       {
90936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90937       };
90938     } catch (std::exception& e) {
90939       {
90940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90941       };
90942     } catch (...) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90945       };
90946     }
90947   }
90948   jresult = result;
90949   return jresult;
90950 }
90951
90952
90953 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
90954   unsigned long jresult ;
90955   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90956   std::size_t result;
90957
90958   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90959   {
90960     try {
90961       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);
90962     } catch (std::out_of_range& e) {
90963       {
90964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90965       };
90966     } catch (std::exception& e) {
90967       {
90968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90969       };
90970     } catch (...) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90973       };
90974     }
90975   }
90976   jresult = (unsigned long)result;
90977   return jresult;
90978 }
90979
90980
90981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90982   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90983   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90984
90985   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90986   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90987   {
90988     try {
90989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90990     } catch (std::out_of_range& e) {
90991       {
90992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90993       };
90994     } catch (std::exception& e) {
90995       {
90996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90997       };
90998     } catch (...) {
90999       {
91000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91001       };
91002     }
91003   }
91004 }
91005
91006
91007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91008   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91009   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91010
91011   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91012   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91013   {
91014     try {
91015       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91016     } catch (std::out_of_range& e) {
91017       {
91018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91019       };
91020     } catch (std::exception& e) {
91021       {
91022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91023       };
91024     } catch (...) {
91025       {
91026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91027       };
91028     }
91029   }
91030 }
91031
91032
91033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91034   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91035   Dali::Toolkit::ProgressBar arg2 ;
91036   float arg3 ;
91037   float arg4 ;
91038   Dali::Toolkit::ProgressBar *argp2 ;
91039
91040   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91041   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91042   if (!argp2) {
91043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91044     return ;
91045   }
91046   arg2 = *argp2;
91047   arg3 = (float)jarg3;
91048   arg4 = (float)jarg4;
91049   {
91050     try {
91051       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91052     } catch (std::out_of_range& e) {
91053       {
91054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91055       };
91056     } catch (std::exception& e) {
91057       {
91058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91059       };
91060     } catch (...) {
91061       {
91062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91063       };
91064     }
91065   }
91066 }
91067
91068
91069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
91070   void * jresult ;
91071   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
91072
91073   {
91074     try {
91075       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
91076     } catch (std::out_of_range& e) {
91077       {
91078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91079       };
91080     } catch (std::exception& e) {
91081       {
91082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91083       };
91084     } catch (...) {
91085       {
91086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91087       };
91088     }
91089   }
91090   jresult = (void *)result;
91091   return jresult;
91092 }
91093
91094
91095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
91096   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91097
91098   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91099   {
91100     try {
91101       delete arg1;
91102     } catch (std::out_of_range& e) {
91103       {
91104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91105       };
91106     } catch (std::exception& e) {
91107       {
91108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91109       };
91110     } catch (...) {
91111       {
91112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91113       };
91114     }
91115   }
91116 }
91117
91118
91119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
91120   unsigned int jresult ;
91121   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91122   bool result;
91123
91124   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91125   {
91126     try {
91127       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);
91128     } catch (std::out_of_range& e) {
91129       {
91130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91131       };
91132     } catch (std::exception& e) {
91133       {
91134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91135       };
91136     } catch (...) {
91137       {
91138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91139       };
91140     }
91141   }
91142   jresult = result;
91143   return jresult;
91144 }
91145
91146
91147 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
91148   unsigned long jresult ;
91149   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91150   std::size_t result;
91151
91152   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91153   {
91154     try {
91155       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);
91156     } catch (std::out_of_range& e) {
91157       {
91158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91159       };
91160     } catch (std::exception& e) {
91161       {
91162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91163       };
91164     } catch (...) {
91165       {
91166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91167       };
91168     }
91169   }
91170   jresult = (unsigned long)result;
91171   return jresult;
91172 }
91173
91174
91175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
91176   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91177   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91178
91179   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91180   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91181   {
91182     try {
91183       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91184     } catch (std::out_of_range& e) {
91185       {
91186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91187       };
91188     } catch (std::exception& e) {
91189       {
91190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91195       };
91196     }
91197   }
91198 }
91199
91200
91201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91202   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91203   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91204
91205   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91206   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91207   {
91208     try {
91209       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91210     } catch (std::out_of_range& e) {
91211       {
91212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91213       };
91214     } catch (std::exception& e) {
91215       {
91216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (...) {
91219       {
91220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91221       };
91222     }
91223   }
91224 }
91225
91226
91227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91228   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91229   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91230
91231   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91232   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91233   if (!arg2) {
91234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91235     return ;
91236   }
91237   {
91238     try {
91239       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91240     } catch (std::out_of_range& e) {
91241       {
91242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91243       };
91244     } catch (std::exception& e) {
91245       {
91246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91247       };
91248     } catch (...) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91251       };
91252     }
91253   }
91254 }
91255
91256
91257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91258   void * jresult ;
91259   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91260
91261   {
91262     try {
91263       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91271       };
91272     } catch (...) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91275       };
91276     }
91277   }
91278   jresult = (void *)result;
91279   return jresult;
91280 }
91281
91282
91283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91284   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91285
91286   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91287   {
91288     try {
91289       delete arg1;
91290     } catch (std::out_of_range& e) {
91291       {
91292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91293       };
91294     } catch (std::exception& e) {
91295       {
91296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91297       };
91298     } catch (...) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91301       };
91302     }
91303   }
91304 }
91305
91306
91307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91308   unsigned int jresult ;
91309   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91310   bool result;
91311
91312   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91313   {
91314     try {
91315       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91316     } catch (std::out_of_range& e) {
91317       {
91318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91319       };
91320     } catch (std::exception& e) {
91321       {
91322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91323       };
91324     } catch (...) {
91325       {
91326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91327       };
91328     }
91329   }
91330   jresult = result;
91331   return jresult;
91332 }
91333
91334
91335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91336   unsigned long jresult ;
91337   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91338   std::size_t result;
91339
91340   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91341   {
91342     try {
91343       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91344     } catch (std::out_of_range& e) {
91345       {
91346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91347       };
91348     } catch (std::exception& e) {
91349       {
91350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91351       };
91352     } catch (...) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91355       };
91356     }
91357   }
91358   jresult = (unsigned long)result;
91359   return jresult;
91360 }
91361
91362
91363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91364   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91365   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91366
91367   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91368   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91369   {
91370     try {
91371       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91372     } catch (std::out_of_range& e) {
91373       {
91374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91375       };
91376     } catch (std::exception& e) {
91377       {
91378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91379       };
91380     } catch (...) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91383       };
91384     }
91385   }
91386 }
91387
91388
91389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91390   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91391   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91392
91393   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91394   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91395   {
91396     try {
91397       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91398     } catch (std::out_of_range& e) {
91399       {
91400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91401       };
91402     } catch (std::exception& e) {
91403       {
91404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91409       };
91410     }
91411   }
91412 }
91413
91414
91415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91416   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91417   Dali::Vector2 *arg2 = 0 ;
91418
91419   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91420   arg2 = (Dali::Vector2 *)jarg2;
91421   if (!arg2) {
91422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91423     return ;
91424   }
91425   {
91426     try {
91427       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91428     } catch (std::out_of_range& e) {
91429       {
91430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91431       };
91432     } catch (std::exception& e) {
91433       {
91434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91435       };
91436     } catch (...) {
91437       {
91438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91439       };
91440     }
91441   }
91442 }
91443
91444
91445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91446   void * jresult ;
91447   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91448
91449   {
91450     try {
91451       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (...) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91463       };
91464     }
91465   }
91466   jresult = (void *)result;
91467   return jresult;
91468 }
91469
91470
91471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91472   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91473
91474   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91475   {
91476     try {
91477       delete arg1;
91478     } catch (std::out_of_range& e) {
91479       {
91480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91481       };
91482     } catch (std::exception& e) {
91483       {
91484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91485       };
91486     } catch (...) {
91487       {
91488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91489       };
91490     }
91491   }
91492 }
91493
91494
91495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91496   unsigned int jresult ;
91497   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91498   bool result;
91499
91500   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91501   {
91502     try {
91503       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91504     } catch (std::out_of_range& e) {
91505       {
91506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91507       };
91508     } catch (std::exception& e) {
91509       {
91510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91511       };
91512     } catch (...) {
91513       {
91514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91515       };
91516     }
91517   }
91518   jresult = result;
91519   return jresult;
91520 }
91521
91522
91523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91524   unsigned long jresult ;
91525   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91526   std::size_t result;
91527
91528   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91529   {
91530     try {
91531       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91532     } catch (std::out_of_range& e) {
91533       {
91534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91535       };
91536     } catch (std::exception& e) {
91537       {
91538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91539       };
91540     } catch (...) {
91541       {
91542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91543       };
91544     }
91545   }
91546   jresult = (unsigned long)result;
91547   return jresult;
91548 }
91549
91550
91551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91552   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91553   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91554
91555   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91556   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91557   {
91558     try {
91559       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91560     } catch (std::out_of_range& e) {
91561       {
91562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91563       };
91564     } catch (std::exception& e) {
91565       {
91566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91571       };
91572     }
91573   }
91574 }
91575
91576
91577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91578   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91579   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91580
91581   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91582   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91583   {
91584     try {
91585       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91586     } catch (std::out_of_range& e) {
91587       {
91588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91589       };
91590     } catch (std::exception& e) {
91591       {
91592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91593       };
91594     } catch (...) {
91595       {
91596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91597       };
91598     }
91599   }
91600 }
91601
91602
91603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91604   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91605   Dali::Toolkit::TextEditor arg2 ;
91606   Dali::Toolkit::TextEditor *argp2 ;
91607
91608   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91609   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91610   if (!argp2) {
91611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91612     return ;
91613   }
91614   arg2 = *argp2;
91615   {
91616     try {
91617       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91618     } catch (std::out_of_range& e) {
91619       {
91620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91621       };
91622     } catch (std::exception& e) {
91623       {
91624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91625       };
91626     } catch (...) {
91627       {
91628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91629       };
91630     }
91631   }
91632 }
91633
91634
91635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91636   void * jresult ;
91637   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91638
91639   {
91640     try {
91641       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91642     } catch (std::out_of_range& e) {
91643       {
91644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91645       };
91646     } catch (std::exception& e) {
91647       {
91648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91649       };
91650     } catch (...) {
91651       {
91652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91653       };
91654     }
91655   }
91656   jresult = (void *)result;
91657   return jresult;
91658 }
91659
91660
91661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91662   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91663
91664   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91665   {
91666     try {
91667       delete arg1;
91668     } catch (std::out_of_range& e) {
91669       {
91670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91671       };
91672     } catch (std::exception& e) {
91673       {
91674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91675       };
91676     } catch (...) {
91677       {
91678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91679       };
91680     }
91681   }
91682 }
91683
91684
91685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91686   unsigned int jresult ;
91687   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91688   bool result;
91689
91690   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91691   {
91692     try {
91693       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91694     } catch (std::out_of_range& e) {
91695       {
91696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (std::exception& e) {
91699       {
91700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91705       };
91706     }
91707   }
91708   jresult = result;
91709   return jresult;
91710 }
91711
91712
91713 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91714   unsigned long jresult ;
91715   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91716   std::size_t result;
91717
91718   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91719   {
91720     try {
91721       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91722     } catch (std::out_of_range& e) {
91723       {
91724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91725       };
91726     } catch (std::exception& e) {
91727       {
91728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91729       };
91730     } catch (...) {
91731       {
91732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91733       };
91734     }
91735   }
91736   jresult = (unsigned long)result;
91737   return jresult;
91738 }
91739
91740
91741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91742   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91743   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91744
91745   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91746   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91747   {
91748     try {
91749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91750     } catch (std::out_of_range& e) {
91751       {
91752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91753       };
91754     } catch (std::exception& e) {
91755       {
91756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91757       };
91758     } catch (...) {
91759       {
91760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91761       };
91762     }
91763   }
91764 }
91765
91766
91767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91768   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91769   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91770
91771   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91772   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91773   {
91774     try {
91775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91776     } catch (std::out_of_range& e) {
91777       {
91778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (std::exception& e) {
91781       {
91782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91783       };
91784     } catch (...) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91787       };
91788     }
91789   }
91790 }
91791
91792
91793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91794   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91795   Dali::Toolkit::TextField arg2 ;
91796   Dali::Toolkit::TextField *argp2 ;
91797
91798   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91799   argp2 = (Dali::Toolkit::TextField *)jarg2;
91800   if (!argp2) {
91801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91802     return ;
91803   }
91804   arg2 = *argp2;
91805   {
91806     try {
91807       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91808     } catch (std::out_of_range& e) {
91809       {
91810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91811       };
91812     } catch (std::exception& e) {
91813       {
91814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91815       };
91816     } catch (...) {
91817       {
91818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91819       };
91820     }
91821   }
91822 }
91823
91824
91825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91826   void * jresult ;
91827   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91828
91829   {
91830     try {
91831       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91843       };
91844     }
91845   }
91846   jresult = (void *)result;
91847   return jresult;
91848 }
91849
91850
91851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91852   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91853
91854   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91855   {
91856     try {
91857       delete arg1;
91858     } catch (std::out_of_range& e) {
91859       {
91860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91861       };
91862     } catch (std::exception& e) {
91863       {
91864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91865       };
91866     } catch (...) {
91867       {
91868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91869       };
91870     }
91871   }
91872 }
91873
91874
91875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91876   unsigned int jresult ;
91877   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91878   bool result;
91879
91880   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91881   {
91882     try {
91883       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);
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (...) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91895       };
91896     }
91897   }
91898   jresult = result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91904   unsigned long jresult ;
91905   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91906   std::size_t result;
91907
91908   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91909   {
91910     try {
91911       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);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91923       };
91924     }
91925   }
91926   jresult = (unsigned long)result;
91927   return jresult;
91928 }
91929
91930
91931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91932   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91933   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91934
91935   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91936   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91937   {
91938     try {
91939       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91940     } catch (std::out_of_range& e) {
91941       {
91942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91943       };
91944     } catch (std::exception& e) {
91945       {
91946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91947       };
91948     } catch (...) {
91949       {
91950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91951       };
91952     }
91953   }
91954 }
91955
91956
91957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91958   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91959   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91960
91961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91962   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91963   {
91964     try {
91965       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91966     } catch (std::out_of_range& e) {
91967       {
91968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91969       };
91970     } catch (std::exception& e) {
91971       {
91972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91973       };
91974     } catch (...) {
91975       {
91976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91977       };
91978     }
91979   }
91980 }
91981
91982
91983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91984   unsigned int jresult ;
91985   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91986   Dali::Toolkit::Control arg2 ;
91987   Dali::KeyEvent *arg3 = 0 ;
91988   Dali::Toolkit::Control *argp2 ;
91989   bool result;
91990
91991   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91992   argp2 = (Dali::Toolkit::Control *)jarg2;
91993   if (!argp2) {
91994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91995     return 0;
91996   }
91997   arg2 = *argp2;
91998   arg3 = (Dali::KeyEvent *)jarg3;
91999   if (!arg3) {
92000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92001     return 0;
92002   }
92003   {
92004     try {
92005       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);
92006     } catch (std::out_of_range& e) {
92007       {
92008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92009       };
92010     } catch (std::exception& e) {
92011       {
92012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92013       };
92014     } catch (...) {
92015       {
92016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92017       };
92018     }
92019   }
92020   jresult = result;
92021   return jresult;
92022 }
92023
92024
92025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92026   void * jresult ;
92027   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92028
92029   {
92030     try {
92031       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92032     } catch (std::out_of_range& e) {
92033       {
92034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92035       };
92036     } catch (std::exception& e) {
92037       {
92038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92039       };
92040     } catch (...) {
92041       {
92042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92043       };
92044     }
92045   }
92046   jresult = (void *)result;
92047   return jresult;
92048 }
92049
92050
92051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92052   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92053
92054   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92055   {
92056     try {
92057       delete arg1;
92058     } catch (std::out_of_range& e) {
92059       {
92060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92061       };
92062     } catch (std::exception& e) {
92063       {
92064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92065       };
92066     } catch (...) {
92067       {
92068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92069       };
92070     }
92071   }
92072 }
92073
92074
92075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92076   unsigned int jresult ;
92077   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92078   bool result;
92079
92080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92081   {
92082     try {
92083       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92084     } catch (std::out_of_range& e) {
92085       {
92086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92087       };
92088     } catch (std::exception& e) {
92089       {
92090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (...) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92095       };
92096     }
92097   }
92098   jresult = result;
92099   return jresult;
92100 }
92101
92102
92103 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92104   unsigned long jresult ;
92105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92106   std::size_t result;
92107
92108   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92109   {
92110     try {
92111       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92112     } catch (std::out_of_range& e) {
92113       {
92114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92115       };
92116     } catch (std::exception& e) {
92117       {
92118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92119       };
92120     } catch (...) {
92121       {
92122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92123       };
92124     }
92125   }
92126   jresult = (unsigned long)result;
92127   return jresult;
92128 }
92129
92130
92131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92132   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92133   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92134
92135   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92136   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92137   {
92138     try {
92139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92140     } catch (std::out_of_range& e) {
92141       {
92142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92143       };
92144     } catch (std::exception& e) {
92145       {
92146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92147       };
92148     } catch (...) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92151       };
92152     }
92153   }
92154 }
92155
92156
92157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92158   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92159   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92160
92161   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92162   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92163   {
92164     try {
92165       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92166     } catch (std::out_of_range& e) {
92167       {
92168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92169       };
92170     } catch (std::exception& e) {
92171       {
92172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92173       };
92174     } catch (...) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92177       };
92178     }
92179   }
92180 }
92181
92182
92183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92184   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92185   Dali::Toolkit::Control arg2 ;
92186   Dali::Toolkit::Control *argp2 ;
92187
92188   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92189   argp2 = (Dali::Toolkit::Control *)jarg2;
92190   if (!argp2) {
92191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92192     return ;
92193   }
92194   arg2 = *argp2;
92195   {
92196     try {
92197       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92198     } catch (std::out_of_range& e) {
92199       {
92200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92201       };
92202     } catch (std::exception& e) {
92203       {
92204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92205       };
92206     } catch (...) {
92207       {
92208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92209       };
92210     }
92211   }
92212 }
92213
92214
92215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92216   void * jresult ;
92217   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92218
92219   {
92220     try {
92221       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92222     } catch (std::out_of_range& e) {
92223       {
92224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (std::exception& e) {
92227       {
92228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (...) {
92231       {
92232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92233       };
92234     }
92235   }
92236   jresult = (void *)result;
92237   return jresult;
92238 }
92239
92240
92241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92242   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92243
92244   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92245   {
92246     try {
92247       delete arg1;
92248     } catch (std::out_of_range& e) {
92249       {
92250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92251       };
92252     } catch (std::exception& e) {
92253       {
92254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92255       };
92256     } catch (...) {
92257       {
92258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92259       };
92260     }
92261   }
92262 }
92263
92264
92265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92266   unsigned int jresult ;
92267   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92268   bool result;
92269
92270   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92271   {
92272     try {
92273       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92274     } catch (std::out_of_range& e) {
92275       {
92276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92277       };
92278     } catch (std::exception& e) {
92279       {
92280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92281       };
92282     } catch (...) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92285       };
92286     }
92287   }
92288   jresult = result;
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92294   unsigned long jresult ;
92295   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92296   std::size_t result;
92297
92298   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92299   {
92300     try {
92301       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92302     } catch (std::out_of_range& e) {
92303       {
92304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92305       };
92306     } catch (std::exception& e) {
92307       {
92308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92309       };
92310     } catch (...) {
92311       {
92312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92313       };
92314     }
92315   }
92316   jresult = (unsigned long)result;
92317   return jresult;
92318 }
92319
92320
92321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92322   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92323   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92324
92325   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92326   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92327   {
92328     try {
92329       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92330     } catch (std::out_of_range& e) {
92331       {
92332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92333       };
92334     } catch (std::exception& e) {
92335       {
92336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92337       };
92338     } catch (...) {
92339       {
92340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92341       };
92342     }
92343   }
92344 }
92345
92346
92347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92348   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92349   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92350
92351   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92352   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92353   {
92354     try {
92355       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92356     } catch (std::out_of_range& e) {
92357       {
92358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92359       };
92360     } catch (std::exception& e) {
92361       {
92362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92363       };
92364     } catch (...) {
92365       {
92366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92367       };
92368     }
92369   }
92370 }
92371
92372
92373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92374   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92375   Dali::Toolkit::VideoView *arg2 = 0 ;
92376
92377   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92378   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92379   if (!arg2) {
92380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92381     return ;
92382   }
92383   {
92384     try {
92385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92386     } catch (std::out_of_range& e) {
92387       {
92388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92389       };
92390     } catch (std::exception& e) {
92391       {
92392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92393       };
92394     } catch (...) {
92395       {
92396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92397       };
92398     }
92399   }
92400 }
92401
92402
92403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92404   void * jresult ;
92405   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92406
92407   {
92408     try {
92409       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92410     } catch (std::out_of_range& e) {
92411       {
92412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92413       };
92414     } catch (std::exception& e) {
92415       {
92416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92417       };
92418     } catch (...) {
92419       {
92420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92421       };
92422     }
92423   }
92424   jresult = (void *)result;
92425   return jresult;
92426 }
92427
92428
92429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92430   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92431
92432   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92433   {
92434     try {
92435       delete arg1;
92436     } catch (std::out_of_range& e) {
92437       {
92438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92439       };
92440     } catch (std::exception& e) {
92441       {
92442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92447       };
92448     }
92449   }
92450 }
92451
92452
92453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92454   unsigned int jresult ;
92455   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92456   bool result;
92457
92458   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92459   {
92460     try {
92461       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92462     } catch (std::out_of_range& e) {
92463       {
92464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92465       };
92466     } catch (std::exception& e) {
92467       {
92468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92469       };
92470     } catch (...) {
92471       {
92472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92473       };
92474     }
92475   }
92476   jresult = result;
92477   return jresult;
92478 }
92479
92480
92481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92482   unsigned long jresult ;
92483   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92484   std::size_t result;
92485
92486   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92487   {
92488     try {
92489       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92490     } catch (std::out_of_range& e) {
92491       {
92492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92493       };
92494     } catch (std::exception& e) {
92495       {
92496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92497       };
92498     } catch (...) {
92499       {
92500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92501       };
92502     }
92503   }
92504   jresult = (unsigned long)result;
92505   return jresult;
92506 }
92507
92508
92509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92510   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92511   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92512
92513   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92514   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92515   {
92516     try {
92517       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92518     } catch (std::out_of_range& e) {
92519       {
92520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (std::exception& e) {
92523       {
92524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92525       };
92526     } catch (...) {
92527       {
92528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92529       };
92530     }
92531   }
92532 }
92533
92534
92535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92536   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92537   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92538
92539   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92540   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92541   {
92542     try {
92543       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92544     } catch (std::out_of_range& e) {
92545       {
92546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92547       };
92548     } catch (std::exception& e) {
92549       {
92550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92555       };
92556     }
92557   }
92558 }
92559
92560
92561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92562   unsigned int jresult ;
92563   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92564   Dali::Toolkit::Slider arg2 ;
92565   float arg3 ;
92566   Dali::Toolkit::Slider *argp2 ;
92567   bool result;
92568
92569   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92570   argp2 = (Dali::Toolkit::Slider *)jarg2;
92571   if (!argp2) {
92572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92573     return 0;
92574   }
92575   arg2 = *argp2;
92576   arg3 = (float)jarg3;
92577   {
92578     try {
92579       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (...) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92591       };
92592     }
92593   }
92594   jresult = result;
92595   return jresult;
92596 }
92597
92598
92599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92600   void * jresult ;
92601   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92602
92603   {
92604     try {
92605       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92606     } catch (std::out_of_range& e) {
92607       {
92608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92609       };
92610     } catch (std::exception& e) {
92611       {
92612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92613       };
92614     } catch (...) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92617       };
92618     }
92619   }
92620   jresult = (void *)result;
92621   return jresult;
92622 }
92623
92624
92625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92626   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92627
92628   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92629   {
92630     try {
92631       delete arg1;
92632     } catch (std::out_of_range& e) {
92633       {
92634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92635       };
92636     } catch (std::exception& e) {
92637       {
92638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92639       };
92640     } catch (...) {
92641       {
92642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92643       };
92644     }
92645   }
92646 }
92647
92648
92649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92650   unsigned int jresult ;
92651   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92652   bool result;
92653
92654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92655   {
92656     try {
92657       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92658     } catch (std::out_of_range& e) {
92659       {
92660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92661       };
92662     } catch (std::exception& e) {
92663       {
92664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92665       };
92666     } catch (...) {
92667       {
92668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92669       };
92670     }
92671   }
92672   jresult = result;
92673   return jresult;
92674 }
92675
92676
92677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92678   unsigned long jresult ;
92679   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92680   std::size_t result;
92681
92682   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92683   {
92684     try {
92685       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92686     } catch (std::out_of_range& e) {
92687       {
92688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92689       };
92690     } catch (std::exception& e) {
92691       {
92692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92693       };
92694     } catch (...) {
92695       {
92696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92697       };
92698     }
92699   }
92700   jresult = (unsigned long)result;
92701   return jresult;
92702 }
92703
92704
92705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92706   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92707   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92708
92709   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92710   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92711   {
92712     try {
92713       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92714     } catch (std::out_of_range& e) {
92715       {
92716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92717       };
92718     } catch (std::exception& e) {
92719       {
92720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92721       };
92722     } catch (...) {
92723       {
92724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92725       };
92726     }
92727   }
92728 }
92729
92730
92731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92732   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92733   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92734
92735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92736   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92737   {
92738     try {
92739       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92740     } catch (std::out_of_range& e) {
92741       {
92742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92743       };
92744     } catch (std::exception& e) {
92745       {
92746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92747       };
92748     } catch (...) {
92749       {
92750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92751       };
92752     }
92753   }
92754 }
92755
92756
92757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92758   unsigned int jresult ;
92759   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92760   Dali::Toolkit::Slider arg2 ;
92761   int arg3 ;
92762   Dali::Toolkit::Slider *argp2 ;
92763   bool result;
92764
92765   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92766   argp2 = (Dali::Toolkit::Slider *)jarg2;
92767   if (!argp2) {
92768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92769     return 0;
92770   }
92771   arg2 = *argp2;
92772   arg3 = (int)jarg3;
92773   {
92774     try {
92775       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92776     } catch (std::out_of_range& e) {
92777       {
92778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92779       };
92780     } catch (std::exception& e) {
92781       {
92782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92783       };
92784     } catch (...) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92787       };
92788     }
92789   }
92790   jresult = result;
92791   return jresult;
92792 }
92793
92794
92795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92796   void * jresult ;
92797   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92798
92799   {
92800     try {
92801       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92802     } catch (std::out_of_range& e) {
92803       {
92804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92805       };
92806     } catch (std::exception& e) {
92807       {
92808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92809       };
92810     } catch (...) {
92811       {
92812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92813       };
92814     }
92815   }
92816   jresult = (void *)result;
92817   return jresult;
92818 }
92819
92820
92821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92822   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92823
92824   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92825   {
92826     try {
92827       delete arg1;
92828     } catch (std::out_of_range& e) {
92829       {
92830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92831       };
92832     } catch (std::exception& e) {
92833       {
92834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92835       };
92836     } catch (...) {
92837       {
92838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92839       };
92840     }
92841   }
92842 }
92843
92844
92845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92846   void * jresult ;
92847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92848
92849   {
92850     try {
92851       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92852     } catch (std::out_of_range& e) {
92853       {
92854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92855       };
92856     } catch (std::exception& e) {
92857       {
92858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92859       };
92860     } catch (...) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92863       };
92864     }
92865   }
92866   jresult = (void *)result;
92867   return jresult;
92868 }
92869
92870
92871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92872   void * jresult ;
92873   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92875
92876   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92877   {
92878     try {
92879       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92880     } catch (std::out_of_range& e) {
92881       {
92882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92883       };
92884     } catch (std::exception& e) {
92885       {
92886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92887       };
92888     } catch (...) {
92889       {
92890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92891       };
92892     }
92893   }
92894   jresult = (void *)result;
92895   return jresult;
92896 }
92897
92898
92899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92900   void * jresult ;
92901   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92902   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92903
92904   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92905   if (!arg1) {
92906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92907     return 0;
92908   }
92909   {
92910     try {
92911       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92912     } catch (std::out_of_range& e) {
92913       {
92914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92915       };
92916     } catch (std::exception& e) {
92917       {
92918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92919       };
92920     } catch (...) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92923       };
92924     }
92925   }
92926   jresult = (void *)result;
92927   return jresult;
92928 }
92929
92930
92931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92932   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92933
92934   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92935   {
92936     try {
92937       delete arg1;
92938     } catch (std::out_of_range& e) {
92939       {
92940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92941       };
92942     } catch (std::exception& e) {
92943       {
92944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92945       };
92946     } catch (...) {
92947       {
92948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92949       };
92950     }
92951   }
92952 }
92953
92954
92955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92956   void * jresult ;
92957   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92958   Dali::Toolkit::Ruler *result = 0 ;
92959
92960   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92961   {
92962     try {
92963       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92964     } catch (std::out_of_range& e) {
92965       {
92966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92967       };
92968     } catch (std::exception& e) {
92969       {
92970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92971       };
92972     } catch (...) {
92973       {
92974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92975       };
92976     }
92977   }
92978   jresult = (void *)result;
92979   return jresult;
92980 }
92981
92982
92983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92984   void * jresult ;
92985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92986   Dali::Toolkit::Ruler *result = 0 ;
92987
92988   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92989   {
92990     try {
92991       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92992     } catch (std::out_of_range& e) {
92993       {
92994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92995       };
92996     } catch (std::exception& e) {
92997       {
92998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92999       };
93000     } catch (...) {
93001       {
93002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93003       };
93004     }
93005   }
93006   jresult = (void *)result;
93007   return jresult;
93008 }
93009
93010
93011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93012   void * jresult ;
93013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93014   Dali::Toolkit::Ruler *result = 0 ;
93015
93016   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93017   {
93018     try {
93019       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93020     } catch (std::out_of_range& e) {
93021       {
93022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93023       };
93024     } catch (std::exception& e) {
93025       {
93026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (...) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93031       };
93032     }
93033   }
93034   jresult = (void *)result;
93035   return jresult;
93036 }
93037
93038
93039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93040   void * jresult ;
93041   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93042   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93043   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93044
93045   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93046   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93047   if (!arg2) {
93048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93049     return 0;
93050   }
93051   {
93052     try {
93053       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93054     } catch (std::out_of_range& e) {
93055       {
93056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93057       };
93058     } catch (std::exception& e) {
93059       {
93060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93061       };
93062     } catch (...) {
93063       {
93064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93065       };
93066     }
93067   }
93068   jresult = (void *)result;
93069   return jresult;
93070 }
93071
93072
93073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93074   void * jresult ;
93075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93076   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93077   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93078
93079   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93080   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93081   {
93082     try {
93083       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93084     } catch (std::out_of_range& e) {
93085       {
93086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93087       };
93088     } catch (std::exception& e) {
93089       {
93090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93095       };
93096     }
93097   }
93098   jresult = (void *)result;
93099   return jresult;
93100 }
93101
93102
93103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93104   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93105
93106   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93107   {
93108     try {
93109       (arg1)->Reset();
93110     } catch (std::out_of_range& e) {
93111       {
93112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93113       };
93114     } catch (std::exception& e) {
93115       {
93116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93117       };
93118     } catch (...) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93121       };
93122     }
93123   }
93124 }
93125
93126
93127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93129   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93130
93131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93132   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93133   {
93134     try {
93135       (arg1)->Reset(arg2);
93136     } catch (std::out_of_range& e) {
93137       {
93138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93139       };
93140     } catch (std::exception& e) {
93141       {
93142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93143       };
93144     } catch (...) {
93145       {
93146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93147       };
93148     }
93149   }
93150 }
93151
93152
93153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
93154   void * jresult ;
93155   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93156   Dali::Toolkit::Ruler *result = 0 ;
93157
93158   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93159   {
93160     try {
93161       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
93162     } catch (std::out_of_range& e) {
93163       {
93164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93165       };
93166     } catch (std::exception& e) {
93167       {
93168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93169       };
93170     } catch (...) {
93171       {
93172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93173       };
93174     }
93175   }
93176   jresult = (void *)result;
93177   return jresult;
93178 }
93179
93180
93181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
93182   float jresult ;
93183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93184   float arg2 ;
93185   float arg3 ;
93186   float result;
93187
93188   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93189   arg2 = (float)jarg2;
93190   arg3 = (float)jarg3;
93191   {
93192     try {
93193       result = (float)(*arg1)->Snap(arg2,arg3);
93194     } catch (std::out_of_range& e) {
93195       {
93196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93197       };
93198     } catch (std::exception& e) {
93199       {
93200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93201       };
93202     } catch (...) {
93203       {
93204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93205       };
93206     }
93207   }
93208   jresult = result;
93209   return jresult;
93210 }
93211
93212
93213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93214   float jresult ;
93215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93216   float arg2 ;
93217   float result;
93218
93219   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93220   arg2 = (float)jarg2;
93221   {
93222     try {
93223       result = (float)(*arg1)->Snap(arg2);
93224     } catch (std::out_of_range& e) {
93225       {
93226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93227       };
93228     } catch (std::exception& e) {
93229       {
93230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93231       };
93232     } catch (...) {
93233       {
93234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93235       };
93236     }
93237   }
93238   jresult = result;
93239   return jresult;
93240 }
93241
93242
93243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93244   float jresult ;
93245   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93246   unsigned int arg2 ;
93247   unsigned int *arg3 = 0 ;
93248   bool arg4 ;
93249   float result;
93250
93251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93252   arg2 = (unsigned int)jarg2;
93253   arg3 = (unsigned int *)jarg3;
93254   arg4 = jarg4 ? true : false;
93255   {
93256     try {
93257       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93258     } catch (std::out_of_range& e) {
93259       {
93260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93261       };
93262     } catch (std::exception& e) {
93263       {
93264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93265       };
93266     } catch (...) {
93267       {
93268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93269       };
93270     }
93271   }
93272   jresult = result;
93273   return jresult;
93274 }
93275
93276
93277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93278   unsigned int jresult ;
93279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93280   float arg2 ;
93281   bool arg3 ;
93282   unsigned int result;
93283
93284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93285   arg2 = (float)jarg2;
93286   arg3 = jarg3 ? true : false;
93287   {
93288     try {
93289       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93290     } catch (std::out_of_range& e) {
93291       {
93292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93293       };
93294     } catch (std::exception& e) {
93295       {
93296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93297       };
93298     } catch (...) {
93299       {
93300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93301       };
93302     }
93303   }
93304   jresult = result;
93305   return jresult;
93306 }
93307
93308
93309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93310   unsigned int jresult ;
93311   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93312   unsigned int result;
93313
93314   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93315   {
93316     try {
93317       result = (unsigned int)(*arg1)->GetTotalPages();
93318     } catch (std::out_of_range& e) {
93319       {
93320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93321       };
93322     } catch (std::exception& e) {
93323       {
93324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93325       };
93326     } catch (...) {
93327       {
93328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93329       };
93330     }
93331   }
93332   jresult = result;
93333   return jresult;
93334 }
93335
93336
93337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93338   int jresult ;
93339   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93340   Dali::Toolkit::Ruler::RulerType result;
93341
93342   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93343   {
93344     try {
93345       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93346     } catch (std::out_of_range& e) {
93347       {
93348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93349       };
93350     } catch (std::exception& e) {
93351       {
93352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93353       };
93354     } catch (...) {
93355       {
93356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93357       };
93358     }
93359   }
93360   jresult = (int)result;
93361   return jresult;
93362 }
93363
93364
93365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93366   unsigned int jresult ;
93367   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93368   bool result;
93369
93370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93371   {
93372     try {
93373       result = (bool)(*arg1)->IsEnabled();
93374     } catch (std::out_of_range& e) {
93375       {
93376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93377       };
93378     } catch (std::exception& e) {
93379       {
93380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93381       };
93382     } catch (...) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93385       };
93386     }
93387   }
93388   jresult = result;
93389   return jresult;
93390 }
93391
93392
93393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93395
93396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93397   {
93398     try {
93399       (*arg1)->Enable();
93400     } catch (std::out_of_range& e) {
93401       {
93402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93403       };
93404     } catch (std::exception& e) {
93405       {
93406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93407       };
93408     } catch (...) {
93409       {
93410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93411       };
93412     }
93413   }
93414 }
93415
93416
93417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93419
93420   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93421   {
93422     try {
93423       (*arg1)->Disable();
93424     } catch (std::out_of_range& e) {
93425       {
93426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93427       };
93428     } catch (std::exception& e) {
93429       {
93430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93431       };
93432     } catch (...) {
93433       {
93434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93435       };
93436     }
93437   }
93438 }
93439
93440
93441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93442   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93443   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93444   Dali::Toolkit::RulerDomain *argp2 ;
93445
93446   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93447   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93448   if (!argp2) {
93449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93450     return ;
93451   }
93452   arg2 = *argp2;
93453   {
93454     try {
93455       (*arg1)->SetDomain(arg2);
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93463       };
93464     } catch (...) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93467       };
93468     }
93469   }
93470 }
93471
93472
93473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93474   void * jresult ;
93475   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93476   Dali::Toolkit::RulerDomain *result = 0 ;
93477
93478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93479   {
93480     try {
93481       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93482     } catch (std::out_of_range& e) {
93483       {
93484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93485       };
93486     } catch (std::exception& e) {
93487       {
93488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93489       };
93490     } catch (...) {
93491       {
93492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93493       };
93494     }
93495   }
93496   jresult = (void *)result;
93497   return jresult;
93498 }
93499
93500
93501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93502   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93503
93504   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93505   {
93506     try {
93507       (*arg1)->DisableDomain();
93508     } catch (std::out_of_range& e) {
93509       {
93510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93511       };
93512     } catch (std::exception& e) {
93513       {
93514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93515       };
93516     } catch (...) {
93517       {
93518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93519       };
93520     }
93521   }
93522 }
93523
93524
93525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93526   float jresult ;
93527   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93528   float arg2 ;
93529   float arg3 ;
93530   float arg4 ;
93531   float result;
93532
93533   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93534   arg2 = (float)jarg2;
93535   arg3 = (float)jarg3;
93536   arg4 = (float)jarg4;
93537   {
93538     try {
93539       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93540     } catch (std::out_of_range& e) {
93541       {
93542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93543       };
93544     } catch (std::exception& e) {
93545       {
93546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93551       };
93552     }
93553   }
93554   jresult = result;
93555   return jresult;
93556 }
93557
93558
93559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93560   float jresult ;
93561   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93562   float arg2 ;
93563   float arg3 ;
93564   float result;
93565
93566   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93567   arg2 = (float)jarg2;
93568   arg3 = (float)jarg3;
93569   {
93570     try {
93571       result = (float)(*arg1)->Clamp(arg2,arg3);
93572     } catch (std::out_of_range& e) {
93573       {
93574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93575       };
93576     } catch (std::exception& e) {
93577       {
93578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93579       };
93580     } catch (...) {
93581       {
93582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93583       };
93584     }
93585   }
93586   jresult = result;
93587   return jresult;
93588 }
93589
93590
93591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93592   float jresult ;
93593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93594   float arg2 ;
93595   float result;
93596
93597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93598   arg2 = (float)jarg2;
93599   {
93600     try {
93601       result = (float)(*arg1)->Clamp(arg2);
93602     } catch (std::out_of_range& e) {
93603       {
93604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93605       };
93606     } catch (std::exception& e) {
93607       {
93608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93609       };
93610     } catch (...) {
93611       {
93612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93613       };
93614     }
93615   }
93616   jresult = result;
93617   return jresult;
93618 }
93619
93620
93621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93622   float jresult ;
93623   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93624   float arg2 ;
93625   float arg3 ;
93626   float arg4 ;
93627   Dali::Toolkit::ClampState *arg5 = 0 ;
93628   float result;
93629
93630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93631   arg2 = (float)jarg2;
93632   arg3 = (float)jarg3;
93633   arg4 = (float)jarg4;
93634   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93635   if (!arg5) {
93636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93637     return 0;
93638   }
93639   {
93640     try {
93641       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93642     } catch (std::out_of_range& e) {
93643       {
93644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93645       };
93646     } catch (std::exception& e) {
93647       {
93648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93649       };
93650     } catch (...) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93653       };
93654     }
93655   }
93656   jresult = result;
93657   return jresult;
93658 }
93659
93660
93661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93662   float jresult ;
93663   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93664   float arg2 ;
93665   float arg3 ;
93666   float arg4 ;
93667   float arg5 ;
93668   float result;
93669
93670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93671   arg2 = (float)jarg2;
93672   arg3 = (float)jarg3;
93673   arg4 = (float)jarg4;
93674   arg5 = (float)jarg5;
93675   {
93676     try {
93677       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93678     } catch (std::out_of_range& e) {
93679       {
93680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93681       };
93682     } catch (std::exception& e) {
93683       {
93684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93685       };
93686     } catch (...) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93689       };
93690     }
93691   }
93692   jresult = result;
93693   return jresult;
93694 }
93695
93696
93697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93698   float jresult ;
93699   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93700   float arg2 ;
93701   float arg3 ;
93702   float arg4 ;
93703   float result;
93704
93705   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93706   arg2 = (float)jarg2;
93707   arg3 = (float)jarg3;
93708   arg4 = (float)jarg4;
93709   {
93710     try {
93711       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93712     } catch (std::out_of_range& e) {
93713       {
93714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93715       };
93716     } catch (std::exception& e) {
93717       {
93718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93719       };
93720     } catch (...) {
93721       {
93722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93723       };
93724     }
93725   }
93726   jresult = result;
93727   return jresult;
93728 }
93729
93730
93731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93732   float jresult ;
93733   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93734   float arg2 ;
93735   float arg3 ;
93736   float result;
93737
93738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93739   arg2 = (float)jarg2;
93740   arg3 = (float)jarg3;
93741   {
93742     try {
93743       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93744     } catch (std::out_of_range& e) {
93745       {
93746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93747       };
93748     } catch (std::exception& e) {
93749       {
93750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93751       };
93752     } catch (...) {
93753       {
93754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93755       };
93756     }
93757   }
93758   jresult = result;
93759   return jresult;
93760 }
93761
93762
93763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93764   float jresult ;
93765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93766   float arg2 ;
93767   float result;
93768
93769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93770   arg2 = (float)jarg2;
93771   {
93772     try {
93773       result = (float)(*arg1)->SnapAndClamp(arg2);
93774     } catch (std::out_of_range& e) {
93775       {
93776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93777       };
93778     } catch (std::exception& e) {
93779       {
93780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93781       };
93782     } catch (...) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93785       };
93786     }
93787   }
93788   jresult = result;
93789   return jresult;
93790 }
93791
93792
93793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93794   float jresult ;
93795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93796   float arg2 ;
93797   float arg3 ;
93798   float arg4 ;
93799   float arg5 ;
93800   Dali::Toolkit::ClampState *arg6 = 0 ;
93801   float result;
93802
93803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93804   arg2 = (float)jarg2;
93805   arg3 = (float)jarg3;
93806   arg4 = (float)jarg4;
93807   arg5 = (float)jarg5;
93808   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93809   if (!arg6) {
93810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93811     return 0;
93812   }
93813   {
93814     try {
93815       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93816     } catch (std::out_of_range& e) {
93817       {
93818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93819       };
93820     } catch (std::exception& e) {
93821       {
93822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93823       };
93824     } catch (...) {
93825       {
93826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93827       };
93828     }
93829   }
93830   jresult = result;
93831   return jresult;
93832 }
93833
93834
93835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93837
93838   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93839   {
93840     try {
93841       (*arg1)->Reference();
93842     } catch (std::out_of_range& e) {
93843       {
93844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93845       };
93846     } catch (std::exception& e) {
93847       {
93848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93849       };
93850     } catch (...) {
93851       {
93852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93853       };
93854     }
93855   }
93856 }
93857
93858
93859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93860   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93861
93862   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93863   {
93864     try {
93865       (*arg1)->Unreference();
93866     } catch (std::out_of_range& e) {
93867       {
93868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93869       };
93870     } catch (std::exception& e) {
93871       {
93872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93873       };
93874     } catch (...) {
93875       {
93876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93877       };
93878     }
93879   }
93880 }
93881
93882
93883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93884   int jresult ;
93885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93886   int result;
93887
93888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93889   {
93890     try {
93891       result = (int)(*arg1)->ReferenceCount();
93892     } catch (std::out_of_range& e) {
93893       {
93894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93895       };
93896     } catch (std::exception& e) {
93897       {
93898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93899       };
93900     } catch (...) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93903       };
93904     }
93905   }
93906   jresult = result;
93907   return jresult;
93908 }
93909
93910
93911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
93912   unsigned int jresult ;
93913   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93914   bool result;
93915
93916   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93917   {
93918     try {
93919       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93920     } catch (std::out_of_range& e) {
93921       {
93922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93923       };
93924     } catch (std::exception& e) {
93925       {
93926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93927       };
93928     } catch (...) {
93929       {
93930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93931       };
93932     }
93933   }
93934   jresult = result;
93935   return jresult;
93936 }
93937
93938
93939 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
93940   unsigned long jresult ;
93941   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93942   std::size_t result;
93943
93944   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93945   {
93946     try {
93947       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93948     } catch (std::out_of_range& e) {
93949       {
93950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93951       };
93952     } catch (std::exception& e) {
93953       {
93954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93955       };
93956     } catch (...) {
93957       {
93958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93959       };
93960     }
93961   }
93962   jresult = (unsigned long)result;
93963   return jresult;
93964 }
93965
93966
93967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
93968   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93969   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93970
93971   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93972   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93973   {
93974     try {
93975       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93976     } catch (std::out_of_range& e) {
93977       {
93978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93979       };
93980     } catch (std::exception& e) {
93981       {
93982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93983       };
93984     } catch (...) {
93985       {
93986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93987       };
93988     }
93989   }
93990 }
93991
93992
93993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
93994   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93995   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93996
93997   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93998   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93999   {
94000     try {
94001       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
94002     } catch (std::out_of_range& e) {
94003       {
94004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94005       };
94006     } catch (std::exception& e) {
94007       {
94008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94009       };
94010     } catch (...) {
94011       {
94012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94013       };
94014     }
94015   }
94016 }
94017
94018
94019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
94020   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94021   Dali::Toolkit::Control arg2 ;
94022   Dali::Toolkit::Control *argp2 ;
94023
94024   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94025   argp2 = (Dali::Toolkit::Control *)jarg2;
94026   if (!argp2) {
94027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
94028     return ;
94029   }
94030   arg2 = *argp2;
94031   {
94032     try {
94033       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
94034     } catch (std::out_of_range& e) {
94035       {
94036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94037       };
94038     } catch (std::exception& e) {
94039       {
94040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94041       };
94042     } catch (...) {
94043       {
94044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94045       };
94046     }
94047   }
94048 }
94049
94050
94051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
94052   void * jresult ;
94053   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
94054
94055   {
94056     try {
94057       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
94058     } catch (std::out_of_range& e) {
94059       {
94060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94061       };
94062     } catch (std::exception& e) {
94063       {
94064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94065       };
94066     } catch (...) {
94067       {
94068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94069       };
94070     }
94071   }
94072   jresult = (void *)result;
94073   return jresult;
94074 }
94075
94076
94077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
94078   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94079
94080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94081   {
94082     try {
94083       delete arg1;
94084     } catch (std::out_of_range& e) {
94085       {
94086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94087       };
94088     } catch (std::exception& e) {
94089       {
94090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94091       };
94092     } catch (...) {
94093       {
94094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94095       };
94096     }
94097   }
94098 }
94099
94100 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
94101     return (Dali::RefObject *)jarg1;
94102 }
94103
94104 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
94105     return (Dali::SignalObserver *)jarg1;
94106 }
94107
94108 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
94109     return (Dali::ConnectionTrackerInterface *)jarg1;
94110 }
94111
94112 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
94113     return (Dali::BaseHandle *)jarg1;
94114 }
94115
94116 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
94117     return (Dali::BaseHandle *)jarg1;
94118 }
94119
94120 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
94121     return (Dali::BaseHandle *)jarg1;
94122 }
94123
94124 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
94125     return (Dali::BaseHandle *)jarg1;
94126 }
94127
94128 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
94129     return (Dali::BaseHandle *)jarg1;
94130 }
94131
94132 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
94133     return (Dali::BaseHandle *)jarg1;
94134 }
94135
94136 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
94137     return (Dali::BaseHandle *)jarg1;
94138 }
94139
94140 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
94141     return (Dali::BaseHandle *)jarg1;
94142 }
94143
94144 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
94145     return (Dali::BaseHandle *)jarg1;
94146 }
94147
94148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
94149     return (Dali::BaseHandle *)jarg1;
94150 }
94151
94152 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
94153     return (Dali::BaseHandle *)jarg1;
94154 }
94155
94156 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
94157     return (Dali::BaseHandle *)jarg1;
94158 }
94159
94160 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
94161     return (Dali::BaseHandle *)jarg1;
94162 }
94163
94164 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
94165     return (Dali::Handle *)jarg1;
94166 }
94167
94168 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
94169     return (Dali::Handle *)jarg1;
94170 }
94171
94172 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
94173     return (Dali::BaseHandle *)jarg1;
94174 }
94175
94176 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
94177     return (Dali::BaseHandle *)jarg1;
94178 }
94179
94180 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
94181     return (Dali::Handle *)jarg1;
94182 }
94183
94184 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
94185     return (Dali::BaseHandle *)jarg1;
94186 }
94187
94188 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
94189     return (Dali::Handle *)jarg1;
94190 }
94191
94192 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
94193     return (Dali::GestureDetector *)jarg1;
94194 }
94195
94196 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
94197     return (Dali::Gesture *)jarg1;
94198 }
94199
94200 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
94201     return (Dali::Handle *)jarg1;
94202 }
94203
94204 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
94205     return (Dali::Actor *)jarg1;
94206 }
94207
94208 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
94209     return (Dali::BaseHandle *)jarg1;
94210 }
94211
94212 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
94213     return (Dali::RefObject *)jarg1;
94214 }
94215
94216 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
94217     return (Dali::Actor *)jarg1;
94218 }
94219
94220 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
94221     return (Dali::GestureDetector *)jarg1;
94222 }
94223
94224 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
94225     return (Dali::Gesture *)jarg1;
94226 }
94227
94228 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
94229     return (Dali::GestureDetector *)jarg1;
94230 }
94231
94232 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
94233     return (Dali::Gesture *)jarg1;
94234 }
94235
94236 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
94237     return (Dali::GestureDetector *)jarg1;
94238 }
94239
94240 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
94241     return (Dali::Gesture *)jarg1;
94242 }
94243
94244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
94245     return (Dali::BaseHandle *)jarg1;
94246 }
94247
94248 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
94249     return (Dali::Handle *)jarg1;
94250 }
94251
94252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
94253     return (Dali::BaseHandle *)jarg1;
94254 }
94255
94256 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
94257     return (Dali::Handle *)jarg1;
94258 }
94259
94260 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
94261     return (Dali::Handle *)jarg1;
94262 }
94263
94264 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
94265     return (Dali::Image *)jarg1;
94266 }
94267
94268 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
94269     return (Dali::Image *)jarg1;
94270 }
94271
94272 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
94273     return (Dali::Image *)jarg1;
94274 }
94275
94276 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
94277     return (Dali::RefObject *)jarg1;
94278 }
94279
94280 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
94281     return (Dali::Image *)jarg1;
94282 }
94283
94284 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
94285     return (Dali::Image *)jarg1;
94286 }
94287
94288 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
94289     return (Dali::ResourceImage *)jarg1;
94290 }
94291
94292 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
94293     return (Dali::Actor *)jarg1;
94294 }
94295
94296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
94297     return (Dali::BaseHandle *)jarg1;
94298 }
94299
94300 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
94301     return (Dali::BaseHandle *)jarg1;
94302 }
94303
94304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
94305     return (Dali::BaseHandle *)jarg1;
94306 }
94307
94308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
94309     return (Dali::BaseHandle *)jarg1;
94310 }
94311
94312 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
94313     return (Dali::BaseHandle *)jarg1;
94314 }
94315
94316 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
94317     return (Dali::BaseHandle *)jarg1;
94318 }
94319
94320 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
94321     return (Dali::CustomActorImpl *)jarg1;
94322 }
94323
94324 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
94325     return (Dali::CustomActor *)jarg1;
94326 }
94327
94328 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
94329     return (Dali::BaseHandle *)jarg1;
94330 }
94331
94332 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
94333     return (Dali::Toolkit::Control *)jarg1;
94334 }
94335
94336 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
94337     return (Dali::Toolkit::Control *)jarg1;
94338 }
94339
94340 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
94341     return (Dali::Toolkit::Button *)jarg1;
94342 }
94343
94344 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
94345     return (Dali::Toolkit::Button *)jarg1;
94346 }
94347
94348 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
94349     return (Dali::Toolkit::Button *)jarg1;
94350 }
94351
94352 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
94353     return (Dali::Toolkit::Control *)jarg1;
94354 }
94355
94356 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
94357     return (Dali::Toolkit::Control *)jarg1;
94358 }
94359
94360 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
94361     return (Dali::Toolkit::Control *)jarg1;
94362 }
94363
94364 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
94365     return (Dali::Toolkit::Control *)jarg1;
94366 }
94367
94368 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
94369     return (Dali::Toolkit::Control *)jarg1;
94370 }
94371
94372 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
94373     return (Dali::RefObject *)jarg1;
94374 }
94375
94376 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
94377     return (Dali::Toolkit::Scrollable *)jarg1;
94378 }
94379
94380 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
94381     return (Dali::BaseHandle *)jarg1;
94382 }
94383
94384 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
94385     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
94386 }
94387
94388 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94389     return (Dali::RefObject *)jarg1;
94390 }
94391
94392 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94393     return (Dali::Toolkit::Ruler *)jarg1;
94394 }
94395
94396 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94397     return (Dali::Toolkit::Ruler *)jarg1;
94398 }
94399
94400 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94401     return (Dali::Toolkit::Scrollable *)jarg1;
94402 }
94403
94404 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94405     return (Dali::Toolkit::Control *)jarg1;
94406 }
94407
94408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94409     return (Dali::Toolkit::Control *)jarg1;
94410 }
94411
94412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94413     return (Dali::Toolkit::Control *)jarg1;
94414 }
94415
94416 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94417     return (Dali::Toolkit::Control *)jarg1;
94418 }
94419
94420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94421     return (Dali::BaseHandle *)jarg1;
94422 }
94423
94424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94425     return (Dali::BaseHandle *)jarg1;
94426 }
94427
94428 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94429     return (Dali::Toolkit::Control *)jarg1;
94430 }
94431
94432 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94433     return (Dali::Toolkit::Control *)jarg1;
94434 }
94435
94436 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94437     return (Dali::Toolkit::Control *)jarg1;
94438 }
94439
94440 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94441     return (Dali::Toolkit::Control *)jarg1;
94442 }
94443
94444 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94445     return (Dali::Toolkit::Control *)jarg1;
94446 }
94447
94448 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94449     return (Dali::Toolkit::Control *)jarg1;
94450 }
94451
94452 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94453     return (Dali::Toolkit::PageTurnView *)jarg1;
94454 }
94455
94456 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94457     return (Dali::Toolkit::PageTurnView *)jarg1;
94458 }
94459
94460 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94461     return (Dali::Toolkit::Button *)jarg1;
94462 }
94463
94464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94465     return (Dali::BaseHandle *)jarg1;
94466 }
94467
94468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94469     return (Dali::BaseHandle *)jarg1;
94470 }
94471
94472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94473     return (Dali::BaseHandle *)jarg1;
94474 }
94475
94476
94477
94478
94479
94480 //////////////////////////////////////////////////
94481 //from dali-swig autogeneration (from dali_wrap.cpp)
94482
94483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
94484   void * jresult ;
94485   Dali::ImfManager::ImfEventData *result = 0 ;
94486
94487   {
94488     try {
94489       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
94490     } catch (std::out_of_range& e) {
94491       {
94492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94493       };
94494     } catch (std::exception& e) {
94495       {
94496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94497       };
94498     } catch (...) {
94499       {
94500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94501       };
94502     }
94503   }
94504   jresult = (void *)result;
94505   return jresult;
94506 }
94507
94508
94509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
94510   void * jresult ;
94511   Dali::ImfManager::ImfEvent arg1 ;
94512   std::string *arg2 = 0 ;
94513   int arg3 ;
94514   int arg4 ;
94515   Dali::ImfManager::ImfEventData *result = 0 ;
94516
94517   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
94518   if (!jarg2) {
94519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94520     return 0;
94521   }
94522   std::string arg2_str(jarg2);
94523   arg2 = &arg2_str;
94524   arg3 = (int)jarg3;
94525   arg4 = (int)jarg4;
94526   {
94527     try {
94528       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
94529     } catch (std::out_of_range& e) {
94530       {
94531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94532       };
94533     } catch (std::exception& e) {
94534       {
94535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94536       };
94537     } catch (...) {
94538       {
94539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94540       };
94541     }
94542   }
94543   jresult = (void *)result;
94544
94545   //argout typemap for const std::string&
94546
94547   return jresult;
94548 }
94549
94550
94551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
94552   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94553   std::string *arg2 = 0 ;
94554
94555   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94556   if (!jarg2) {
94557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94558     return ;
94559   }
94560   std::string arg2_str(jarg2);
94561   arg2 = &arg2_str;
94562   if (arg1) (arg1)->predictiveString = *arg2;
94563
94564   //argout typemap for const std::string&
94565
94566 }
94567
94568
94569 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
94570   char * jresult ;
94571   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94572   std::string *result = 0 ;
94573
94574   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94575   result = (std::string *) & ((arg1)->predictiveString);
94576   jresult = SWIG_csharp_string_callback(result->c_str());
94577   return jresult;
94578 }
94579
94580
94581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
94582   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94583   Dali::ImfManager::ImfEvent arg2 ;
94584
94585   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94586   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
94587   if (arg1) (arg1)->eventName = arg2;
94588 }
94589
94590
94591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
94592   int jresult ;
94593   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94594   Dali::ImfManager::ImfEvent result;
94595
94596   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94597   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
94598   jresult = (int)result;
94599   return jresult;
94600 }
94601
94602
94603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
94604   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94605   int arg2 ;
94606
94607   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94608   arg2 = (int)jarg2;
94609   if (arg1) (arg1)->cursorOffset = arg2;
94610 }
94611
94612
94613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
94614   int jresult ;
94615   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94616   int result;
94617
94618   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94619   result = (int) ((arg1)->cursorOffset);
94620   jresult = result;
94621   return jresult;
94622 }
94623
94624
94625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
94626   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94627   int arg2 ;
94628
94629   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94630   arg2 = (int)jarg2;
94631   if (arg1) (arg1)->numberOfChars = arg2;
94632 }
94633
94634
94635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
94636   int jresult ;
94637   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94638   int result;
94639
94640   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94641   result = (int) ((arg1)->numberOfChars);
94642   jresult = result;
94643   return jresult;
94644 }
94645
94646
94647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
94648   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
94649
94650   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
94651   {
94652     try {
94653       delete arg1;
94654     } catch (std::out_of_range& e) {
94655       {
94656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94657       };
94658     } catch (std::exception& e) {
94659       {
94660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94661       };
94662     } catch (...) {
94663       {
94664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94665       };
94666     }
94667   }
94668 }
94669
94670
94671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
94672   void * jresult ;
94673   Dali::ImfManager::ImfCallbackData *result = 0 ;
94674
94675   {
94676     try {
94677       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
94678     } catch (std::out_of_range& e) {
94679       {
94680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94681       };
94682     } catch (std::exception& e) {
94683       {
94684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94685       };
94686     } catch (...) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94689       };
94690     }
94691   }
94692   jresult = (void *)result;
94693   return jresult;
94694 }
94695
94696
94697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
94698   void * jresult ;
94699   bool arg1 ;
94700   int arg2 ;
94701   std::string *arg3 = 0 ;
94702   bool arg4 ;
94703   Dali::ImfManager::ImfCallbackData *result = 0 ;
94704
94705   arg1 = jarg1 ? true : false;
94706   arg2 = (int)jarg2;
94707   if (!jarg3) {
94708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94709     return 0;
94710   }
94711   std::string arg3_str(jarg3);
94712   arg3 = &arg3_str;
94713   arg4 = jarg4 ? true : false;
94714   {
94715     try {
94716       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
94717     } catch (std::out_of_range& e) {
94718       {
94719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94720       };
94721     } catch (std::exception& e) {
94722       {
94723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94724       };
94725     } catch (...) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94728       };
94729     }
94730   }
94731   jresult = (void *)result;
94732
94733   //argout typemap for const std::string&
94734
94735   return jresult;
94736 }
94737
94738
94739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
94740   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94741   std::string *arg2 = 0 ;
94742
94743   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94744   if (!jarg2) {
94745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94746     return ;
94747   }
94748   std::string arg2_str(jarg2);
94749   arg2 = &arg2_str;
94750   if (arg1) (arg1)->currentText = *arg2;
94751
94752   //argout typemap for const std::string&
94753
94754 }
94755
94756
94757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
94758   char * jresult ;
94759   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94760   std::string *result = 0 ;
94761
94762   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94763   result = (std::string *) & ((arg1)->currentText);
94764   jresult = SWIG_csharp_string_callback(result->c_str());
94765   return jresult;
94766 }
94767
94768
94769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
94770   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94771   int arg2 ;
94772
94773   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94774   arg2 = (int)jarg2;
94775   if (arg1) (arg1)->cursorPosition = arg2;
94776 }
94777
94778
94779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
94780   int jresult ;
94781   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94782   int result;
94783
94784   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94785   result = (int) ((arg1)->cursorPosition);
94786   jresult = result;
94787   return jresult;
94788 }
94789
94790
94791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
94792   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94793   bool arg2 ;
94794
94795   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94796   arg2 = jarg2 ? true : false;
94797   if (arg1) (arg1)->update = arg2;
94798 }
94799
94800
94801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
94802   unsigned int jresult ;
94803   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94804   bool result;
94805
94806   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94807   result = (bool) ((arg1)->update);
94808   jresult = result;
94809   return jresult;
94810 }
94811
94812
94813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
94814   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94815   bool arg2 ;
94816
94817   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94818   arg2 = jarg2 ? true : false;
94819   if (arg1) (arg1)->preeditResetRequired = arg2;
94820 }
94821
94822
94823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
94824   unsigned int jresult ;
94825   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94826   bool result;
94827
94828   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94829   result = (bool) ((arg1)->preeditResetRequired);
94830   jresult = result;
94831   return jresult;
94832 }
94833
94834
94835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
94836   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
94837
94838   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
94839   {
94840     try {
94841       delete arg1;
94842     } catch (std::out_of_range& e) {
94843       {
94844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94845       };
94846     } catch (std::exception& e) {
94847       {
94848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94849       };
94850     } catch (...) {
94851       {
94852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94853       };
94854     }
94855   }
94856 }
94857
94858
94859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
94860   void * jresult ;
94861   Dali::ImfManager result;
94862
94863   {
94864     try {
94865       result = Dali::ImfManager::Get();
94866     } catch (std::out_of_range& e) {
94867       {
94868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94869       };
94870     } catch (std::exception& e) {
94871       {
94872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94873       };
94874     } catch (...) {
94875       {
94876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94877       };
94878     }
94879   }
94880   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
94881   return jresult;
94882 }
94883
94884
94885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
94886   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94887
94888   arg1 = (Dali::ImfManager *)jarg1;
94889   {
94890     try {
94891       (arg1)->Activate();
94892     } catch (std::out_of_range& e) {
94893       {
94894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (std::exception& e) {
94897       {
94898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94899       };
94900     } catch (...) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94903       };
94904     }
94905   }
94906 }
94907
94908
94909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
94910   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94911
94912   arg1 = (Dali::ImfManager *)jarg1;
94913   {
94914     try {
94915       (arg1)->Deactivate();
94916     } catch (std::out_of_range& e) {
94917       {
94918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94919       };
94920     } catch (std::exception& e) {
94921       {
94922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94923       };
94924     } catch (...) {
94925       {
94926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94927       };
94928     }
94929   }
94930 }
94931
94932
94933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
94934   unsigned int jresult ;
94935   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94936   bool result;
94937
94938   arg1 = (Dali::ImfManager *)jarg1;
94939   {
94940     try {
94941       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
94942     } catch (std::out_of_range& e) {
94943       {
94944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94945       };
94946     } catch (std::exception& e) {
94947       {
94948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94949       };
94950     } catch (...) {
94951       {
94952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94953       };
94954     }
94955   }
94956   jresult = result;
94957   return jresult;
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
94962   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94963   bool arg2 ;
94964
94965   arg1 = (Dali::ImfManager *)jarg1;
94966   arg2 = jarg2 ? true : false;
94967   {
94968     try {
94969       (arg1)->SetRestoreAfterFocusLost(arg2);
94970     } catch (std::out_of_range& e) {
94971       {
94972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94973       };
94974     } catch (std::exception& e) {
94975       {
94976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94977       };
94978     } catch (...) {
94979       {
94980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94981       };
94982     }
94983   }
94984 }
94985
94986
94987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
94988   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94989
94990   arg1 = (Dali::ImfManager *)jarg1;
94991   {
94992     try {
94993       (arg1)->Reset();
94994     } catch (std::out_of_range& e) {
94995       {
94996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94997       };
94998     } catch (std::exception& e) {
94999       {
95000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95001       };
95002     } catch (...) {
95003       {
95004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95005       };
95006     }
95007   }
95008 }
95009
95010
95011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
95012   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95013
95014   arg1 = (Dali::ImfManager *)jarg1;
95015   {
95016     try {
95017       (arg1)->NotifyCursorPosition();
95018     } catch (std::out_of_range& e) {
95019       {
95020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95021       };
95022     } catch (std::exception& e) {
95023       {
95024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95025       };
95026     } catch (...) {
95027       {
95028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95029       };
95030     }
95031   }
95032 }
95033
95034
95035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
95036   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95037   unsigned int arg2 ;
95038
95039   arg1 = (Dali::ImfManager *)jarg1;
95040   arg2 = (unsigned int)jarg2;
95041   {
95042     try {
95043       (arg1)->SetCursorPosition(arg2);
95044     } catch (std::out_of_range& e) {
95045       {
95046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95047       };
95048     } catch (std::exception& e) {
95049       {
95050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95051       };
95052     } catch (...) {
95053       {
95054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95055       };
95056     }
95057   }
95058 }
95059
95060
95061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
95062   unsigned int jresult ;
95063   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95064   unsigned int result;
95065
95066   arg1 = (Dali::ImfManager *)jarg1;
95067   {
95068     try {
95069       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
95070     } catch (std::out_of_range& e) {
95071       {
95072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95073       };
95074     } catch (std::exception& e) {
95075       {
95076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95077       };
95078     } catch (...) {
95079       {
95080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95081       };
95082     }
95083   }
95084   jresult = result;
95085   return jresult;
95086 }
95087
95088
95089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
95090   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95091   std::string *arg2 = 0 ;
95092
95093   arg1 = (Dali::ImfManager *)jarg1;
95094   if (!jarg2) {
95095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95096     return ;
95097   }
95098   std::string arg2_str(jarg2);
95099   arg2 = &arg2_str;
95100   {
95101     try {
95102       (arg1)->SetSurroundingText((std::string const &)*arg2);
95103     } catch (std::out_of_range& e) {
95104       {
95105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95106       };
95107     } catch (std::exception& e) {
95108       {
95109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95110       };
95111     } catch (...) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95114       };
95115     }
95116   }
95117
95118   //argout typemap for const std::string&
95119
95120 }
95121
95122
95123 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
95124   char * jresult ;
95125   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95126   std::string *result = 0 ;
95127
95128   arg1 = (Dali::ImfManager *)jarg1;
95129   {
95130     try {
95131       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
95132     } catch (std::out_of_range& e) {
95133       {
95134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95135       };
95136     } catch (std::exception& e) {
95137       {
95138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95139       };
95140     } catch (...) {
95141       {
95142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95143       };
95144     }
95145   }
95146   jresult = SWIG_csharp_string_callback(result->c_str());
95147   return jresult;
95148 }
95149
95150
95151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
95152   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95153   bool arg2 ;
95154
95155   arg1 = (Dali::ImfManager *)jarg1;
95156   arg2 = jarg2 ? true : false;
95157   {
95158     try {
95159       (arg1)->NotifyTextInputMultiLine(arg2);
95160     } catch (std::out_of_range& e) {
95161       {
95162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95163       };
95164     } catch (std::exception& e) {
95165       {
95166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95167       };
95168     } catch (...) {
95169       {
95170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95171       };
95172     }
95173   }
95174 }
95175
95176
95177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
95178   int jresult ;
95179   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95180   Dali::ImfManager::TextDirection result;
95181
95182   arg1 = (Dali::ImfManager *)jarg1;
95183   {
95184     try {
95185       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
95186     } catch (std::out_of_range& e) {
95187       {
95188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95189       };
95190     } catch (std::exception& e) {
95191       {
95192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95193       };
95194     } catch (...) {
95195       {
95196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95197       };
95198     }
95199   }
95200   jresult = (int)result;
95201   return jresult;
95202 }
95203
95204
95205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
95206   void * jresult ;
95207   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95208   Dali::Rect< int > result;
95209
95210   arg1 = (Dali::ImfManager *)jarg1;
95211   {
95212     try {
95213       result = (arg1)->GetInputMethodArea();
95214     } catch (std::out_of_range& e) {
95215       {
95216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (std::exception& e) {
95219       {
95220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (...) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95225       };
95226     }
95227   }
95228   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
95229   return jresult;
95230 }
95231
95232
95233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
95234   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95235   Dali::InputMethodOptions *arg2 = 0 ;
95236
95237   arg1 = (Dali::ImfManager *)jarg1;
95238   arg2 = (Dali::InputMethodOptions *)jarg2;
95239   if (!arg2) {
95240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
95241     return ;
95242   }
95243   {
95244     try {
95245       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
95246     } catch (std::out_of_range& e) {
95247       {
95248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95249       };
95250     } catch (std::exception& e) {
95251       {
95252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95253       };
95254     } catch (...) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95257       };
95258     }
95259   }
95260 }
95261
95262
95263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
95264   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95265   std::string *arg2 = 0 ;
95266
95267   arg1 = (Dali::ImfManager *)jarg1;
95268   if (!jarg2) {
95269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95270     return ;
95271   }
95272   std::string arg2_str(jarg2);
95273   arg2 = &arg2_str;
95274   {
95275     try {
95276       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
95277     } catch (std::out_of_range& e) {
95278       {
95279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95280       };
95281     } catch (std::exception& e) {
95282       {
95283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95284       };
95285     } catch (...) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95288       };
95289     }
95290   }
95291
95292   //argout typemap for const std::string&
95293
95294 }
95295
95296
95297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
95298   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95299   std::string *arg2 = 0 ;
95300
95301   arg1 = (Dali::ImfManager *)jarg1;
95302   if (!jarg2) {
95303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95304     return ;
95305   }
95306   std::string arg2_str(jarg2);
95307   arg2 = &arg2_str;
95308   {
95309     try {
95310       (arg1)->GetInputPanelUserData((std::string &)*arg2);
95311     } catch (std::out_of_range& e) {
95312       {
95313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95314       };
95315     } catch (std::exception& e) {
95316       {
95317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95318       };
95319     } catch (...) {
95320       {
95321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95322       };
95323     }
95324   }
95325
95326 }
95327
95328
95329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
95330   int jresult ;
95331   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95332   Dali::ImfManager::State result;
95333
95334   arg1 = (Dali::ImfManager *)jarg1;
95335   {
95336     try {
95337       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
95338     } catch (std::out_of_range& e) {
95339       {
95340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95341       };
95342     } catch (std::exception& e) {
95343       {
95344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95345       };
95346     } catch (...) {
95347       {
95348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95349       };
95350     }
95351   }
95352   jresult = (int)result;
95353   return jresult;
95354 }
95355
95356
95357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
95358   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95359   bool arg2 ;
95360
95361   arg1 = (Dali::ImfManager *)jarg1;
95362   arg2 = jarg2 ? true : false;
95363   {
95364     try {
95365       (arg1)->SetReturnKeyState(arg2);
95366     } catch (std::out_of_range& e) {
95367       {
95368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95369       };
95370     } catch (std::exception& e) {
95371       {
95372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95373       };
95374     } catch (...) {
95375       {
95376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95377       };
95378     }
95379   }
95380 }
95381
95382
95383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
95384   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95385   bool arg2 ;
95386
95387   arg1 = (Dali::ImfManager *)jarg1;
95388   arg2 = jarg2 ? true : false;
95389   {
95390     try {
95391       (arg1)->AutoEnableInputPanel(arg2);
95392     } catch (std::out_of_range& e) {
95393       {
95394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95395       };
95396     } catch (std::exception& e) {
95397       {
95398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95399       };
95400     } catch (...) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95403       };
95404     }
95405   }
95406 }
95407
95408
95409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
95410   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95411
95412   arg1 = (Dali::ImfManager *)jarg1;
95413   {
95414     try {
95415       (arg1)->ShowInputPanel();
95416     } catch (std::out_of_range& e) {
95417       {
95418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95419       };
95420     } catch (std::exception& e) {
95421       {
95422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95423       };
95424     } catch (...) {
95425       {
95426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95427       };
95428     }
95429   }
95430 }
95431
95432
95433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
95434   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95435
95436   arg1 = (Dali::ImfManager *)jarg1;
95437   {
95438     try {
95439       (arg1)->HideInputPanel();
95440     } catch (std::out_of_range& e) {
95441       {
95442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95443       };
95444     } catch (std::exception& e) {
95445       {
95446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95447       };
95448     } catch (...) {
95449       {
95450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95451       };
95452     }
95453   }
95454 }
95455
95456
95457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
95458   void * jresult ;
95459   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95460   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
95461
95462   arg1 = (Dali::ImfManager *)jarg1;
95463   {
95464     try {
95465       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
95466     } catch (std::out_of_range& e) {
95467       {
95468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95469       };
95470     } catch (std::exception& e) {
95471       {
95472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95473       };
95474     } catch (...) {
95475       {
95476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95477       };
95478     }
95479   }
95480   jresult = (void *)result;
95481   return jresult;
95482 }
95483
95484
95485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
95486   void * jresult ;
95487   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95488   Dali::ImfManager::ImfEventSignalType *result = 0 ;
95489
95490   arg1 = (Dali::ImfManager *)jarg1;
95491   {
95492     try {
95493       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
95494     } catch (std::out_of_range& e) {
95495       {
95496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95497       };
95498     } catch (std::exception& e) {
95499       {
95500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95501       };
95502     } catch (...) {
95503       {
95504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95505       };
95506     }
95507   }
95508   jresult = (void *)result;
95509   return jresult;
95510 }
95511
95512
95513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
95514   void * jresult ;
95515   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95516   Dali::ImfManager::StatusSignalType *result = 0 ;
95517
95518   arg1 = (Dali::ImfManager *)jarg1;
95519   {
95520     try {
95521       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
95522     } catch (std::out_of_range& e) {
95523       {
95524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95525       };
95526     } catch (std::exception& e) {
95527       {
95528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95529       };
95530     } catch (...) {
95531       {
95532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95533       };
95534     }
95535   }
95536   jresult = (void *)result;
95537   return jresult;
95538 }
95539
95540
95541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
95542   void * jresult ;
95543   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95544   Dali::ImfManager::VoidSignalType *result = 0 ;
95545
95546   arg1 = (Dali::ImfManager *)jarg1;
95547   {
95548     try {
95549       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
95550     } catch (std::out_of_range& e) {
95551       {
95552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95553       };
95554     } catch (std::exception& e) {
95555       {
95556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95557       };
95558     } catch (...) {
95559       {
95560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95561       };
95562     }
95563   }
95564   jresult = (void *)result;
95565   return jresult;
95566 }
95567
95568
95569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
95570   void * jresult ;
95571   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95572   Dali::ImfManager::VoidSignalType *result = 0 ;
95573
95574   arg1 = (Dali::ImfManager *)jarg1;
95575   {
95576     try {
95577       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
95578     } catch (std::out_of_range& e) {
95579       {
95580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95581       };
95582     } catch (std::exception& e) {
95583       {
95584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95585       };
95586     } catch (...) {
95587       {
95588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95589       };
95590     }
95591   }
95592   jresult = (void *)result;
95593   return jresult;
95594 }
95595
95596
95597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
95598   void * jresult ;
95599   Dali::ImfManager *result = 0 ;
95600
95601   {
95602     try {
95603       result = (Dali::ImfManager *)new Dali::ImfManager();
95604     } catch (std::out_of_range& e) {
95605       {
95606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95607       };
95608     } catch (std::exception& e) {
95609       {
95610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95611       };
95612     } catch (...) {
95613       {
95614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95615       };
95616     }
95617   }
95618   jresult = (void *)result;
95619   return jresult;
95620 }
95621
95622
95623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
95624   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
95625
95626   arg1 = (Dali::ImfManager *)jarg1;
95627   {
95628     try {
95629       delete arg1;
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95637       };
95638     } catch (...) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95641       };
95642     }
95643   }
95644 }
95645
95646
95647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
95648   void * jresult ;
95649   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
95650   Dali::ImfManager *result = 0 ;
95651
95652   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
95653   {
95654     try {
95655       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
95656     } catch (std::out_of_range& e) {
95657       {
95658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95659       };
95660     } catch (std::exception& e) {
95661       {
95662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95663       };
95664     } catch (...) {
95665       {
95666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95667       };
95668     }
95669   }
95670   jresult = (void *)result;
95671   return jresult;
95672 }
95673
95674
95675 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
95676     return (Dali::BaseHandle *)jarg1;
95677 }
95678
95679
95680 //////////////////////////////////////////////////
95681 //from dali-swig autogeneration (from dali_wrap.cpp)
95682
95683
95684
95685
95686
95687
95688
95689
95690
95691
95692
95693
95694 #ifdef __cplusplus
95695 }
95696 #endif
95697